From 9b0887017a09e3c1ee7e9c2df066d8b2da30db48 Mon Sep 17 00:00:00 2001
From: Daniel Lew <danlew42@gmail.com>
Date: Fri, 29 Apr 2016 00:56:57 -0500
Subject: [PATCH 001/263] throwIfFatal() now throws OnCompletedFailedException
 (#3886)

Otherwise, if there's an error in onCompleted, the exception is
swallowed and unreported.
---
 src/main/java/rx/exceptions/Exceptions.java   |  3 +++
 .../java/rx/exceptions/ExceptionsTest.java    | 22 +++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/src/main/java/rx/exceptions/Exceptions.java b/src/main/java/rx/exceptions/Exceptions.java
index 6c37167c3e..f427018f53 100644
--- a/src/main/java/rx/exceptions/Exceptions.java
+++ b/src/main/java/rx/exceptions/Exceptions.java
@@ -61,6 +61,7 @@ public static RuntimeException propagate(Throwable t) {
      * <ul>
      * <li>{@link OnErrorNotImplementedException}</li>
      * <li>{@link OnErrorFailedException}</li>
+     * <li>{@link OnCompletedFailedException}</li>
      * <li>{@code StackOverflowError}</li>
      * <li>{@code VirtualMachineError}</li>
      * <li>{@code ThreadDeath}</li>
@@ -80,6 +81,8 @@ public static void throwIfFatal(Throwable t) {
             throw (OnErrorNotImplementedException) t;
         } else if (t instanceof OnErrorFailedException) {
             throw (OnErrorFailedException) t;
+        } else if (t instanceof OnCompletedFailedException) {
+            throw (OnCompletedFailedException) t;
         }
         // values here derived from https://github.com/ReactiveX/RxJava/issues/748#issuecomment-32471495
         else if (t instanceof StackOverflowError) {
diff --git a/src/test/java/rx/exceptions/ExceptionsTest.java b/src/test/java/rx/exceptions/ExceptionsTest.java
index 5906a6d6f9..9f63e41fa1 100644
--- a/src/test/java/rx/exceptions/ExceptionsTest.java
+++ b/src/test/java/rx/exceptions/ExceptionsTest.java
@@ -46,6 +46,28 @@ public void call(Integer t1) {
         });
     }
 
+    /**
+     * https://github.com/ReactiveX/RxJava/issues/3885
+     */
+    @Test(expected = OnCompletedFailedException.class)
+    public void testOnCompletedExceptionIsThrown() {
+        Observable.empty()
+            .subscribe(new Subscriber<Object>() {
+                @Override
+                public void onCompleted() {
+                    throw new RuntimeException();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                }
+
+                @Override
+                public void onNext(Object o) {
+                }
+            });
+    }
+
     @Test
     public void testStackOverflowWouldOccur() {
         final PublishSubject<Integer> a = PublishSubject.create();

From 8c8244080667592172d997f4cc5eaf89a7788afa Mon Sep 17 00:00:00 2001
From: Artem Zinnatullin <artem.zinnatullin@gmail.com>
Date: Fri, 29 Apr 2016 20:46:47 +0300
Subject: [PATCH 002/263] 1.x: TestSubscriber/TestObserver print values if
 number of items doesn't match (#3880)

---
 src/main/java/rx/observers/TestObserver.java  |  6 +++++-
 .../java/rx/observers/TestObserverTest.java   |  4 +++-
 .../java/rx/observers/TestSubscriberTest.java | 20 +++++++++++++++++++
 3 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/observers/TestObserver.java b/src/main/java/rx/observers/TestObserver.java
index c20784187a..928956980b 100644
--- a/src/main/java/rx/observers/TestObserver.java
+++ b/src/main/java/rx/observers/TestObserver.java
@@ -113,7 +113,11 @@ public List<Object> getEvents() {
      */
     public void assertReceivedOnNext(List<T> items) {
         if (onNextEvents.size() != items.size()) {
-            throw new AssertionError("Number of items does not match. Provided: " + items.size() + "  Actual: " + onNextEvents.size());
+            throw new AssertionError("Number of items does not match. Provided: " + items.size() + "  Actual: " + onNextEvents.size()
+            + ".\n"
+            + "Provided values: " + items
+            + "\n"
+            + "Actual values: " + onNextEvents);
         }
 
         for (int i = 0; i < items.size(); i++) {
diff --git a/src/test/java/rx/observers/TestObserverTest.java b/src/test/java/rx/observers/TestObserverTest.java
index 53f7a06746..117455294f 100644
--- a/src/test/java/rx/observers/TestObserverTest.java
+++ b/src/test/java/rx/observers/TestObserverTest.java
@@ -53,7 +53,9 @@ public void testAssertNotMatchCount() {
         oi.subscribe(o);
 
         thrown.expect(AssertionError.class);
-        thrown.expectMessage("Number of items does not match. Provided: 1  Actual: 2");
+        thrown.expectMessage("Number of items does not match. Provided: 1  Actual: 2.\n" +
+                "Provided values: [1]\n" +
+                "Actual values: [1, 2]");
 
         o.assertReceivedOnNext(Arrays.asList(1));
         assertEquals(2, o.getOnNextEvents().size());
diff --git a/src/test/java/rx/observers/TestSubscriberTest.java b/src/test/java/rx/observers/TestSubscriberTest.java
index 1076d2152f..1974a81a2f 100644
--- a/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/src/test/java/rx/observers/TestSubscriberTest.java
@@ -595,4 +595,24 @@ public void onError(Throwable e) {
         
         ts.awaitTerminalEvent();
     }
+
+    @Test
+    public void assertValuesShouldThrowIfNumberOfItemsDoesNotMatch() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+
+        ts.onNext("a");
+        ts.onNext("b");
+        ts.onNext("c");
+
+        try {
+            ts.assertValues("1", "2");
+            fail();
+        } catch (AssertionError expected) {
+            assertEquals("Number of items does not match. Provided: 2  Actual: 3.\n" +
+                    "Provided values: [1, 2]\n" +
+                    "Actual values: [a, b, c]",
+                    expected.getMessage()
+            );
+        }
+    }
 }

From 5da378fbedcbb3cbd1fd1ec30b672e317ce5df1c Mon Sep 17 00:00:00 2001
From: Jake Wharton <jakewharton@gmail.com>
Date: Fri, 29 Apr 2016 14:13:19 -0400
Subject: [PATCH 003/263] Expose scheduler factories which accept thread
 factories. (#3879)

This allows hooks to create schedulers whose threads have different priorities.
---
 .../schedulers/CachedThreadScheduler.java     |  33 +++--
 .../schedulers/EventLoopsScheduler.java       |  19 ++-
 .../schedulers/NewThreadScheduler.java        |  11 +-
 .../rx/internal/util/RxThreadFactory.java     |   6 +
 .../java/rx/plugins/RxJavaSchedulersHook.java |  38 ++++-
 .../operators/OperatorObserveOnTest.java      |   6 +-
 .../rx/plugins/RxJavaSchedulersHookTest.java  | 139 ++++++++++++++++++
 .../schedulers/ComputationSchedulerTests.java |   4 +-
 .../java/rx/schedulers/IoSchedulerTest.java   |   2 +-
 9 files changed, 218 insertions(+), 40 deletions(-)
 create mode 100644 src/test/java/rx/plugins/RxJavaSchedulersHookTest.java

diff --git a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
index 472ade9109..1ebfa56fe4 100644
--- a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
+++ b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
@@ -24,31 +24,25 @@
 import rx.subscriptions.*;
 
 public final class CachedThreadScheduler extends Scheduler implements SchedulerLifecycle {
-    private static final String WORKER_THREAD_NAME_PREFIX = "RxCachedThreadScheduler-";
-    static final RxThreadFactory WORKER_THREAD_FACTORY =
-            new RxThreadFactory(WORKER_THREAD_NAME_PREFIX);
-
-    private static final String EVICTOR_THREAD_NAME_PREFIX = "RxCachedWorkerPoolEvictor-";
-    static final RxThreadFactory EVICTOR_THREAD_FACTORY =
-            new RxThreadFactory(EVICTOR_THREAD_NAME_PREFIX);
-
     private static final long KEEP_ALIVE_TIME = 60;
     private static final TimeUnit KEEP_ALIVE_UNIT = TimeUnit.SECONDS;
     
     static final ThreadWorker SHUTDOWN_THREADWORKER;
     static {
-        SHUTDOWN_THREADWORKER = new ThreadWorker(new RxThreadFactory("RxCachedThreadSchedulerShutdown-"));
+        SHUTDOWN_THREADWORKER = new ThreadWorker(RxThreadFactory.NONE);
         SHUTDOWN_THREADWORKER.unsubscribe();
     }
     
     private static final class CachedWorkerPool {
+        private final ThreadFactory threadFactory;
         private final long keepAliveTime;
         private final ConcurrentLinkedQueue<ThreadWorker> expiringWorkerQueue;
         private final CompositeSubscription allWorkers;
         private final ScheduledExecutorService evictorService;
         private final Future<?> evictorTask;
 
-        CachedWorkerPool(long keepAliveTime, TimeUnit unit) {
+        CachedWorkerPool(final ThreadFactory threadFactory, long keepAliveTime, TimeUnit unit) {
+            this.threadFactory = threadFactory;
             this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0L;
             this.expiringWorkerQueue = new ConcurrentLinkedQueue<ThreadWorker>();
             this.allWorkers = new CompositeSubscription();
@@ -56,7 +50,13 @@ private static final class CachedWorkerPool {
             ScheduledExecutorService evictor = null;
             Future<?> task = null;
             if (unit != null) {
-                evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
+                evictor = Executors.newScheduledThreadPool(1, new ThreadFactory() {
+                    @Override public Thread newThread(Runnable r) {
+                        Thread thread = threadFactory.newThread(r);
+                        thread.setName(thread.getName() + " (Evictor)");
+                        return thread;
+                    }
+                });
                 NewThreadWorker.tryEnableCancelPolicy(evictor);
                 task = evictor.scheduleWithFixedDelay(
                         new Runnable() {
@@ -83,7 +83,7 @@ ThreadWorker get() {
             }
 
             // No cached worker found, so create a new one.
-            ThreadWorker w = new ThreadWorker(WORKER_THREAD_FACTORY);
+            ThreadWorker w = new ThreadWorker(threadFactory);
             allWorkers.add(w);
             return w;
         }
@@ -131,22 +131,25 @@ void shutdown() {
         }
     }
 
+    final ThreadFactory threadFactory;
     final AtomicReference<CachedWorkerPool> pool;
     
     static final CachedWorkerPool NONE;
     static {
-        NONE = new CachedWorkerPool(0, null);
+        NONE = new CachedWorkerPool(null, 0, null);
         NONE.shutdown();
     }
     
-    public CachedThreadScheduler() {
+    public CachedThreadScheduler(ThreadFactory threadFactory) {
+        this.threadFactory = threadFactory;
         this.pool = new AtomicReference<CachedWorkerPool>(NONE);
         start();
     }
     
     @Override
     public void start() {
-        CachedWorkerPool update = new CachedWorkerPool(KEEP_ALIVE_TIME, KEEP_ALIVE_UNIT);
+        CachedWorkerPool update =
+            new CachedWorkerPool(threadFactory, KEEP_ALIVE_TIME, KEEP_ALIVE_UNIT);
         if (!pool.compareAndSet(NONE, update)) {
             update.shutdown();
         }
diff --git a/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java b/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
index 1eef164937..8f4a5f34a2 100644
--- a/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
+++ b/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
@@ -23,10 +23,7 @@
 import rx.internal.util.*;
 import rx.subscriptions.*;
 
-public class EventLoopsScheduler extends Scheduler implements SchedulerLifecycle {
-    /** Manages a fixed number of workers. */
-    private static final String THREAD_NAME_PREFIX = "RxComputationThreadPool-";
-    static final RxThreadFactory THREAD_FACTORY = new RxThreadFactory(THREAD_NAME_PREFIX);
+public final class EventLoopsScheduler extends Scheduler implements SchedulerLifecycle {
     /**
      * Key to setting the maximum number of computation scheduler threads.
      * Zero or less is interpreted as use available. Capped by available.
@@ -48,7 +45,7 @@ public class EventLoopsScheduler extends Scheduler implements SchedulerLifecycle
     
     static final PoolWorker SHUTDOWN_WORKER;
     static {
-        SHUTDOWN_WORKER = new PoolWorker(new RxThreadFactory("RxComputationShutdown-"));
+        SHUTDOWN_WORKER = new PoolWorker(RxThreadFactory.NONE);
         SHUTDOWN_WORKER.unsubscribe();
     }
     
@@ -58,12 +55,12 @@ static final class FixedSchedulerPool {
         final PoolWorker[] eventLoops;
         long n;
 
-        FixedSchedulerPool(int maxThreads) {
+        FixedSchedulerPool(ThreadFactory threadFactory, int maxThreads) {
             // initialize event loops
             this.cores = maxThreads;
             this.eventLoops = new PoolWorker[maxThreads];
             for (int i = 0; i < maxThreads; i++) {
-                this.eventLoops[i] = new PoolWorker(THREAD_FACTORY);
+                this.eventLoops[i] = new PoolWorker(threadFactory);
             }
         }
 
@@ -83,15 +80,17 @@ public void shutdown() {
         }
     }
     /** This will indicate no pool is active. */
-    static final FixedSchedulerPool NONE = new FixedSchedulerPool(0);
+    static final FixedSchedulerPool NONE = new FixedSchedulerPool(null, 0);
 
+    final ThreadFactory threadFactory;
     final AtomicReference<FixedSchedulerPool> pool;
     
     /**
      * Create a scheduler with pool size equal to the available processor
      * count and using least-recent worker selection policy.
      */
-    public EventLoopsScheduler() {
+    public EventLoopsScheduler(ThreadFactory threadFactory) {
+        this.threadFactory = threadFactory;
         this.pool = new AtomicReference<FixedSchedulerPool>(NONE);
         start();
     }
@@ -103,7 +102,7 @@ public Worker createWorker() {
     
     @Override
     public void start() {
-        FixedSchedulerPool update = new FixedSchedulerPool(MAX_THREADS);
+        FixedSchedulerPool update = new FixedSchedulerPool(threadFactory, MAX_THREADS);
         if (!pool.compareAndSet(NONE, update)) {
             update.shutdown();
         }
diff --git a/src/main/java/rx/internal/schedulers/NewThreadScheduler.java b/src/main/java/rx/internal/schedulers/NewThreadScheduler.java
index 19aaedf8db..96d04026f9 100644
--- a/src/main/java/rx/internal/schedulers/NewThreadScheduler.java
+++ b/src/main/java/rx/internal/schedulers/NewThreadScheduler.java
@@ -15,22 +15,21 @@
  */
 package rx.internal.schedulers;
 
+import java.util.concurrent.ThreadFactory;
 import rx.Scheduler;
-import rx.internal.util.RxThreadFactory;
 
 /**
  * Schedules work on a new thread.
  */
 public final class NewThreadScheduler extends Scheduler {
+    private final ThreadFactory threadFactory;
 
-    private static final String THREAD_NAME_PREFIX = "RxNewThreadScheduler-";
-    private static final RxThreadFactory THREAD_FACTORY = new RxThreadFactory(THREAD_NAME_PREFIX);
-
-    public NewThreadScheduler() {
+    public NewThreadScheduler(ThreadFactory threadFactory) {
+        this.threadFactory = threadFactory;
     }
 
     @Override
     public Worker createWorker() {
-        return new NewThreadWorker(THREAD_FACTORY);
+        return new NewThreadWorker(threadFactory);
     }
 }
diff --git a/src/main/java/rx/internal/util/RxThreadFactory.java b/src/main/java/rx/internal/util/RxThreadFactory.java
index cc6d45d486..1259f4a9e1 100644
--- a/src/main/java/rx/internal/util/RxThreadFactory.java
+++ b/src/main/java/rx/internal/util/RxThreadFactory.java
@@ -19,6 +19,12 @@
 import java.util.concurrent.atomic.AtomicLong;
 
 public final class RxThreadFactory extends AtomicLong implements ThreadFactory {
+    public static final ThreadFactory NONE = new ThreadFactory() {
+        @Override public Thread newThread(Runnable r) {
+            throw new AssertionError("No threads allowed.");
+        }
+    };
+
     final String prefix;
 
     public RxThreadFactory(String prefix) {
diff --git a/src/main/java/rx/plugins/RxJavaSchedulersHook.java b/src/main/java/rx/plugins/RxJavaSchedulersHook.java
index 38d09dede9..00ed84e442 100644
--- a/src/main/java/rx/plugins/RxJavaSchedulersHook.java
+++ b/src/main/java/rx/plugins/RxJavaSchedulersHook.java
@@ -16,12 +16,14 @@
 
 package rx.plugins;
 
+import java.util.concurrent.ThreadFactory;
 import rx.Scheduler;
 import rx.annotations.Experimental;
 import rx.functions.Action0;
 import rx.internal.schedulers.CachedThreadScheduler;
 import rx.internal.schedulers.EventLoopsScheduler;
 import rx.internal.schedulers.NewThreadScheduler;
+import rx.internal.util.RxThreadFactory;
 import rx.schedulers.Schedulers;
 
 /**
@@ -45,7 +47,17 @@ public class RxJavaSchedulersHook {
      */
     @Experimental
     public static Scheduler createComputationScheduler() {
-        return new EventLoopsScheduler();
+        return createComputationScheduler(new RxThreadFactory("RxComputationScheduler-"));
+    }
+
+    /**
+     * Create an instance of the default {@link Scheduler} used for {@link Schedulers#computation()}
+     * except using {@code threadFactory} for thread creation.
+     */
+    @Experimental
+    public static Scheduler createComputationScheduler(ThreadFactory threadFactory) {
+        if (threadFactory == null) throw new NullPointerException("threadFactory == null");
+        return new EventLoopsScheduler(threadFactory);
     }
 
     /**
@@ -53,7 +65,17 @@ public static Scheduler createComputationScheduler() {
      */
     @Experimental
     public static Scheduler createIoScheduler() {
-        return new CachedThreadScheduler();
+        return createIoScheduler(new RxThreadFactory("RxIoScheduler-"));
+    }
+
+    /**
+     * Create an instance of the default {@link Scheduler} used for {@link Schedulers#io()}
+     * except using {@code threadFactory} for thread creation.
+     */
+    @Experimental
+    public static Scheduler createIoScheduler(ThreadFactory threadFactory) {
+        if (threadFactory == null) throw new NullPointerException("threadFactory == null");
+        return new CachedThreadScheduler(threadFactory);
     }
 
     /**
@@ -61,7 +83,17 @@ public static Scheduler createIoScheduler() {
      */
     @Experimental
     public static Scheduler createNewThreadScheduler() {
-        return new NewThreadScheduler();
+        return createNewThreadScheduler(new RxThreadFactory("RxNewThreadScheduler-"));
+    }
+
+    /**
+     * Create an instance of the default {@link Scheduler} used for {@link Schedulers#newThread()}
+     * except using {@code threadFactory} for thread creation.
+     */
+    @Experimental
+    public static Scheduler createNewThreadScheduler(ThreadFactory threadFactory) {
+        if (threadFactory == null) throw new NullPointerException("threadFactory == null");
+        return new NewThreadScheduler(threadFactory);
     }
 
     protected RxJavaSchedulersHook() {
diff --git a/src/test/java/rx/internal/operators/OperatorObserveOnTest.java b/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
index 29c1a4a8d5..6e066c19ad 100644
--- a/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
@@ -238,7 +238,7 @@ public void call(Integer t1) {
      * Confirm that running on a ThreadPoolScheduler allows multiple threads but is still ordered.
      */
     @Test
-    public void testObserveOnWithThreadPoolScheduler() {
+    public void testObserveOnWithComputationScheduler() {
         final AtomicInteger count = new AtomicInteger();
         final int _multiple = 99;
 
@@ -255,7 +255,7 @@ public Integer call(Integer t1) {
                     @Override
                     public void call(Integer t1) {
                         assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
-                        assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
+                        assertTrue(Thread.currentThread().getName().startsWith("RxComputationScheduler"));
                     }
 
                 });
@@ -295,7 +295,7 @@ public Integer call(Integer t1) {
                     @Override
                     public void call(Integer t1) {
                         assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
-                        assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
+                        assertTrue(Thread.currentThread().getName().startsWith("RxComputationScheduler"));
                     }
 
                 });
diff --git a/src/test/java/rx/plugins/RxJavaSchedulersHookTest.java b/src/test/java/rx/plugins/RxJavaSchedulersHookTest.java
new file mode 100644
index 0000000000..dfbfbf1d6c
--- /dev/null
+++ b/src/test/java/rx/plugins/RxJavaSchedulersHookTest.java
@@ -0,0 +1,139 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.plugins;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Test;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.functions.Action0;
+import rx.internal.schedulers.SchedulerLifecycle;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+public final class RxJavaSchedulersHookTest {
+    @Test
+    public void schedulerFactoriesDisallowNull() {
+        try {
+            RxJavaSchedulersHook.createComputationScheduler(null);
+            fail();
+        } catch (NullPointerException e) {
+            assertEquals("threadFactory == null", e.getMessage());
+        }
+        try {
+            RxJavaSchedulersHook.createIoScheduler(null);
+            fail();
+        } catch (NullPointerException e) {
+            assertEquals("threadFactory == null", e.getMessage());
+        }
+        try {
+            RxJavaSchedulersHook.createNewThreadScheduler(null);
+            fail();
+        } catch (NullPointerException e) {
+            assertEquals("threadFactory == null", e.getMessage());
+        }
+    }
+
+    @Test public void computationSchedulerUsesSuppliedThreadFactory() throws InterruptedException {
+        final AtomicReference<Thread> threadRef = new AtomicReference<Thread>();
+        ThreadFactory threadFactory = new ThreadFactory() {
+            @Override
+            public Thread newThread(Runnable r) {
+                Thread thread = new Thread(r);
+                threadRef.set(thread);
+                return thread;
+            }
+        };
+
+        Scheduler scheduler = RxJavaSchedulersHook.createComputationScheduler(threadFactory);
+        Worker worker = scheduler.createWorker();
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        worker.schedule(new Action0() {
+            @Override
+            public void call() {
+                assertSame(threadRef.get(), Thread.currentThread());
+                latch.countDown();
+            }
+        });
+        assertTrue(latch.await(10, SECONDS));
+
+        if (scheduler instanceof SchedulerLifecycle) {
+            ((SchedulerLifecycle) scheduler).shutdown();
+        }
+    }
+
+    @Test public void ioSchedulerUsesSuppliedThreadFactory() throws InterruptedException {
+        final AtomicReference<Thread> threadRef = new AtomicReference<Thread>();
+        ThreadFactory threadFactory = new ThreadFactory() {
+            @Override
+            public Thread newThread(Runnable r) {
+                Thread thread = new Thread(r);
+                threadRef.set(thread);
+                return thread;
+            }
+        };
+
+        Scheduler scheduler = RxJavaSchedulersHook.createIoScheduler(threadFactory);
+        Worker worker = scheduler.createWorker();
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        worker.schedule(new Action0() {
+            @Override public void call() {
+                assertSame(threadRef.get(), Thread.currentThread());
+                latch.countDown();
+            }
+        });
+        assertTrue(latch.await(10, SECONDS));
+
+        if (scheduler instanceof SchedulerLifecycle) {
+            ((SchedulerLifecycle) scheduler).shutdown();
+        }
+    }
+
+    @Test public void newThreadSchedulerUsesSuppliedThreadFactory() throws InterruptedException {
+        final AtomicReference<Thread> threadRef = new AtomicReference<Thread>();
+        ThreadFactory threadFactory = new ThreadFactory() {
+            @Override public Thread newThread(Runnable r) {
+              Thread thread = new Thread(r);
+              threadRef.set(thread);
+              return thread;
+            }
+        };
+
+        Scheduler scheduler = RxJavaSchedulersHook.createNewThreadScheduler(threadFactory);
+        Worker worker = scheduler.createWorker();
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        worker.schedule(new Action0() {
+            @Override public void call() {
+              assertSame(threadRef.get(), Thread.currentThread());
+              latch.countDown();
+          }
+          });
+        assertTrue(latch.await(10, SECONDS));
+
+        if (scheduler instanceof SchedulerLifecycle) {
+            ((SchedulerLifecycle) scheduler).shutdown();
+        }
+    }
+}
diff --git a/src/test/java/rx/schedulers/ComputationSchedulerTests.java b/src/test/java/rx/schedulers/ComputationSchedulerTests.java
index 7e9163e7c0..392ee03ccd 100644
--- a/src/test/java/rx/schedulers/ComputationSchedulerTests.java
+++ b/src/test/java/rx/schedulers/ComputationSchedulerTests.java
@@ -102,7 +102,7 @@ public final void testComputationThreadPool1() {
 
             @Override
             public String call(Integer t) {
-                assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
+                assertTrue(Thread.currentThread().getName().startsWith("RxComputationScheduler"));
                 return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
             }
         });
@@ -129,7 +129,7 @@ public final void testMergeWithExecutorScheduler() {
             @Override
             public String call(Integer t) {
                 assertFalse(Thread.currentThread().getName().equals(currentThreadName));
-                assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool"));
+                assertTrue(Thread.currentThread().getName().startsWith("RxComputationScheduler"));
                 return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
             }
         });
diff --git a/src/test/java/rx/schedulers/IoSchedulerTest.java b/src/test/java/rx/schedulers/IoSchedulerTest.java
index a16a19a61c..38ddb2a2dd 100644
--- a/src/test/java/rx/schedulers/IoSchedulerTest.java
+++ b/src/test/java/rx/schedulers/IoSchedulerTest.java
@@ -43,7 +43,7 @@ public final void testIOScheduler() {
 
             @Override
             public String call(Integer t) {
-                assertTrue(Thread.currentThread().getName().startsWith("RxCachedThreadScheduler"));
+                assertTrue(Thread.currentThread().getName().startsWith("RxIoScheduler"));
                 return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
             }
         });

From e58c4a74606397f0a199cbe68bf6ce58ebec171d Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 29 Apr 2016 20:14:36 +0200
Subject: [PATCH 004/263] Have undeliverable errors on subscribe() sent to
 plugin error handler. (#3887)

---
 src/main/java/rx/Observable.java | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 92e9ea56fa..1ca8527d23 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -8530,18 +8530,23 @@ static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T
         } catch (Throwable e) {
             // special handling for certain Throwable/Error/Exception types
             Exceptions.throwIfFatal(e);
-            // if an unhandled error occurs executing the onSubscribe we will propagate it
-            try {
-                subscriber.onError(hook.onSubscribeError(e));
-            } catch (Throwable e2) {
-                Exceptions.throwIfFatal(e2);
-                // if this happens it means the onError itself failed (perhaps an invalid function implementation)
-                // so we are unable to propagate the error correctly and will just throw
-                RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
-                // TODO could the hook be the cause of the error in the on error handling.
-                hook.onSubscribeError(r);
-                // TODO why aren't we throwing the hook's return value.
-                throw r;
+            // in case the subscriber can't listen to exceptions anymore
+            if (subscriber.isUnsubscribed()) {
+                RxJavaPluginUtils.handleException(hook.onSubscribeError(e));
+            } else {
+                // if an unhandled error occurs executing the onSubscribe we will propagate it
+                try {
+                    subscriber.onError(hook.onSubscribeError(e));
+                } catch (Throwable e2) {
+                    Exceptions.throwIfFatal(e2);
+                    // if this happens it means the onError itself failed (perhaps an invalid function implementation)
+                    // so we are unable to propagate the error correctly and will just throw
+                    RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
+                    // TODO could the hook be the cause of the error in the on error handling.
+                    hook.onSubscribeError(r);
+                    // TODO why aren't we throwing the hook's return value.
+                    throw r;
+                }
             }
             return Subscriptions.unsubscribed();
         }

From 89fd2dd3d9032052eaab7feed724ae37a7a81d85 Mon Sep 17 00:00:00 2001
From: Shivang Shah <shivangshah@users.noreply.github.com>
Date: Fri, 29 Apr 2016 11:15:18 -0700
Subject: [PATCH 005/263] Making RxPlugins reset() public (#3820)

Discussions found here: https://github.com/ReactiveX/RxJava/issues/2297
Adding @experimental tag because exposing reset() could be dangerous
Adding javadocs for `reset()` API.
Explicitly mentioning how caution is advised when using `reset()` API.
Also mentioning links to detailed discussions on github issue.
---
 src/main/java/rx/plugins/RxJavaPlugins.java | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/plugins/RxJavaPlugins.java b/src/main/java/rx/plugins/RxJavaPlugins.java
index acedd07449..622916c661 100644
--- a/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -17,6 +17,7 @@
 
 import java.util.*;
 import java.util.concurrent.atomic.AtomicReference;
+import rx.annotations.Experimental;
 
 /**
  * Registry for plugin implementations that allows global override and handles the retrieval of correct
@@ -65,8 +66,18 @@ public static RxJavaPlugins getInstance() {
     /* package accessible for unit tests */RxJavaPlugins() {
 
     }
-
-    /* package accessible for unit tests */void reset() {
+    
+    /**
+     * Reset {@code RxJavaPlugins} instance
+     * <p>
+     * This API is experimental. Resetting the plugins is dangerous 
+     * during application runtime and also bad code could invoke it in 
+     * the middle of an application life-cycle and really break applications
+     * if not used cautiously. For more detailed discussions:
+     * * @see <a href="https://github.com/ReactiveX/RxJava/issues/2297">Make RxJavaPlugins.reset() public</a>
+     */
+    @Experimental
+    public void reset() {
         INSTANCE.errorHandler.set(null);
         INSTANCE.observableExecutionHook.set(null);
         INSTANCE.singleExecutionHook.set(null);

From cf63347b88098dd930d0c09d5513b7fe48e9c6aa Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 29 Apr 2016 20:40:49 +0200
Subject: [PATCH 006/263] 1.x: Give more time to
 OperatorSwitchTest.switchAsyncHeavily (#3897)

* 1.x: Give more time to OperatorSwitchTest.switchAsyncHeavily

* Also print last seen how long time ago
---
 .../java/rx/internal/operators/OperatorSwitchTest.java     | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/test/java/rx/internal/operators/OperatorSwitchTest.java b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
index b673b56949..9a8178cb28 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
@@ -837,12 +837,15 @@ public void switchAsyncHeavily() {
             
             final Queue<Throwable> q = new ConcurrentLinkedQueue<Throwable>();
             
+            final long[] lastSeen = { 0L };
+            
             final int j = i;
             TestSubscriber<Integer> ts = new TestSubscriber<Integer>(i) {
                 int count;
                 @Override
                 public void onNext(Integer t) {
                     super.onNext(t);
+                    lastSeen[0] = System.currentTimeMillis();
                     if (++count == j) {
                         count = 0;
                         requestMore(j);
@@ -867,13 +870,13 @@ public void call(Throwable e) {
             .timeout(10, TimeUnit.SECONDS)
             .subscribe(ts);
             
-            ts.awaitTerminalEvent(30, TimeUnit.SECONDS);
+            ts.awaitTerminalEvent(45, TimeUnit.SECONDS);
             if (!q.isEmpty()) {
                 throw new AssertionError("Dropped exceptions", new CompositeException(q));
             }
             ts.assertNoErrors();
             if (ts.getOnCompletedEvents().size() == 0) {
-                fail("switchAsyncHeavily timed out @ " + j + " (" + ts.getOnNextEvents().size() + " onNexts received)");
+                fail("switchAsyncHeavily timed out @ " + j + " (" + ts.getOnNextEvents().size() + " onNexts received, last was " + (System.currentTimeMillis() - lastSeen[0]) + " ms ago");
             }
         }
     }

From 123c5f99833d2ca9b5b7bf193fc224cab9c38f6e Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 29 Apr 2016 21:36:23 +0200
Subject: [PATCH 007/263] 1.x: Add missing license headers (#3898)

---
 .../operators/OnSubscribeFromCallable.java    | 16 ++++++++++
 .../operators/OperatorTakeLastOne.java        | 16 ++++++++++
 .../operators/SingleOnSubscribeUsing.java     | 16 ++++++++++
 .../SingleOperatorOnErrorResumeNext.java      | 16 ++++++++++
 .../internal/operators/SingleOperatorZip.java | 16 ++++++++++
 .../schedulers/SchedulerLifecycle.java        | 16 ++++++++++
 .../rx/operators/OperatorTakeLastOnePerf.java | 16 ++++++++++
 .../rx/CapturingUncaughtExceptionHandler.java | 16 ++++++++++
 src/test/java/rx/NotificationTest.java        | 16 ++++++++++
 .../java/rx/ObservableConversionTest.java     | 16 ++++++++++
 .../OnSubscribeConcatDelayErrorTest.java      | 16 ++++++++++
 .../OnSubscribeFromCallableTest.java          | 16 ++++++++++
 .../operators/OperatorDoOnRequestTest.java    | 16 ++++++++++
 .../operators/OperatorIgnoreElementsTest.java | 16 ++++++++++
 .../operators/OperatorTakeLastOneTest.java    | 16 ++++++++++
 ...OnSubscribeDelaySubscriptionOtherTest.java | 16 ++++++++++
 .../GenericScheduledExecutorServiceTest.java  | 16 ++++++++++
 .../schedulers/NewThreadWorkerTest.java       | 16 ++++++++++
 .../rx/internal/util/JCToolsQueueTests.java   | 31 ++++++++++---------
 .../internal/util/SynchronizedQueueTest.java  | 16 ++++++++++
 .../rx/observables/AsyncOnSubscribeTest.java  | 16 ++++++++++
 .../rx/schedulers/SchedulerLifecycleTest.java | 16 ++++++++++
 .../java/rx/schedulers/SchedulerTests.java    | 16 ++++++++++
 23 files changed, 368 insertions(+), 15 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java b/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java
index ed7f2183c4..02e4d4cb93 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import rx.Observable;
diff --git a/src/main/java/rx/internal/operators/OperatorTakeLastOne.java b/src/main/java/rx/internal/operators/OperatorTakeLastOne.java
index 6f8bf86259..2c20f2a465 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeLastOne.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeLastOne.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import java.util.concurrent.atomic.AtomicInteger;
diff --git a/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java b/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
index 8bd73a29b0..54cdfe5c24 100644
--- a/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
+++ b/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import java.util.Arrays;
diff --git a/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java b/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
index 584551376c..0b0ee1c8f7 100644
--- a/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
+++ b/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import rx.Single;
diff --git a/src/main/java/rx/internal/operators/SingleOperatorZip.java b/src/main/java/rx/internal/operators/SingleOperatorZip.java
index d80c5ae056..7614a6a6c5 100644
--- a/src/main/java/rx/internal/operators/SingleOperatorZip.java
+++ b/src/main/java/rx/internal/operators/SingleOperatorZip.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import rx.Single;
diff --git a/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java b/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java
index a9c7bd3f12..498030b6ff 100644
--- a/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java
+++ b/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.schedulers;
 
 /**
diff --git a/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java b/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
index 43adf76bc5..c04c73fa9b 100644
--- a/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
+++ b/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.operators;
 
 import org.openjdk.jmh.annotations.Benchmark;
diff --git a/src/test/java/rx/CapturingUncaughtExceptionHandler.java b/src/test/java/rx/CapturingUncaughtExceptionHandler.java
index 52b809a3c1..a44c6df080 100644
--- a/src/test/java/rx/CapturingUncaughtExceptionHandler.java
+++ b/src/test/java/rx/CapturingUncaughtExceptionHandler.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx;
 
 import java.util.concurrent.CountDownLatch;
diff --git a/src/test/java/rx/NotificationTest.java b/src/test/java/rx/NotificationTest.java
index cf33fb991a..7de7749940 100644
--- a/src/test/java/rx/NotificationTest.java
+++ b/src/test/java/rx/NotificationTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx;
 
 import org.junit.Assert;
diff --git a/src/test/java/rx/ObservableConversionTest.java b/src/test/java/rx/ObservableConversionTest.java
index 31880ea599..9e2f6e7cdd 100644
--- a/src/test/java/rx/ObservableConversionTest.java
+++ b/src/test/java/rx/ObservableConversionTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx;
 
 import java.util.Arrays;
diff --git a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
index 86e929d8de..b61630f837 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import org.junit.Test;
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromCallableTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromCallableTest.java
index a4da6e3208..0c939d6b65 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromCallableTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromCallableTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import org.junit.Test;
diff --git a/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java b/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
index 80f5fd4fc8..371b0826ed 100644
--- a/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import static org.junit.Assert.*;
diff --git a/src/test/java/rx/internal/operators/OperatorIgnoreElementsTest.java b/src/test/java/rx/internal/operators/OperatorIgnoreElementsTest.java
index 818f228ba8..92424da031 100644
--- a/src/test/java/rx/internal/operators/OperatorIgnoreElementsTest.java
+++ b/src/test/java/rx/internal/operators/OperatorIgnoreElementsTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import static org.junit.Assert.assertEquals;
diff --git a/src/test/java/rx/internal/operators/OperatorTakeLastOneTest.java b/src/test/java/rx/internal/operators/OperatorTakeLastOneTest.java
index 2dcae73fc0..0ea5bc6be1 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeLastOneTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeLastOneTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import static org.junit.Assert.assertEquals;
diff --git a/src/test/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOtherTest.java b/src/test/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOtherTest.java
index c17f3b6e1f..4aed52288c 100644
--- a/src/test/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOtherTest.java
+++ b/src/test/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOtherTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import org.junit.Assert;
diff --git a/src/test/java/rx/internal/schedulers/GenericScheduledExecutorServiceTest.java b/src/test/java/rx/internal/schedulers/GenericScheduledExecutorServiceTest.java
index 0b90bce072..6bb8800c97 100644
--- a/src/test/java/rx/internal/schedulers/GenericScheduledExecutorServiceTest.java
+++ b/src/test/java/rx/internal/schedulers/GenericScheduledExecutorServiceTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.schedulers;
 
 import java.util.concurrent.*;
diff --git a/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java b/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java
index c0d6f93dda..dbb6362401 100644
--- a/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java
+++ b/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.schedulers;
 
 import org.junit.Test;
diff --git a/src/test/java/rx/internal/util/JCToolsQueueTests.java b/src/test/java/rx/internal/util/JCToolsQueueTests.java
index fdf844bf81..a9f845b772 100644
--- a/src/test/java/rx/internal/util/JCToolsQueueTests.java
+++ b/src/test/java/rx/internal/util/JCToolsQueueTests.java
@@ -1,18 +1,19 @@
-    /**
-     * Copyright 2014 Netflix, Inc.
-     * 
-     * 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.
-     */
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.util;
 
 import static org.junit.Assert.*;
diff --git a/src/test/java/rx/internal/util/SynchronizedQueueTest.java b/src/test/java/rx/internal/util/SynchronizedQueueTest.java
index 98779ea1b9..aea871711a 100644
--- a/src/test/java/rx/internal/util/SynchronizedQueueTest.java
+++ b/src/test/java/rx/internal/util/SynchronizedQueueTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.util;
 
 import static org.junit.Assert.assertTrue;
diff --git a/src/test/java/rx/observables/AsyncOnSubscribeTest.java b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
index cd74520971..71370e84f3 100644
--- a/src/test/java/rx/observables/AsyncOnSubscribeTest.java
+++ b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.observables;
 
 import static org.junit.Assert.assertEquals;
diff --git a/src/test/java/rx/schedulers/SchedulerLifecycleTest.java b/src/test/java/rx/schedulers/SchedulerLifecycleTest.java
index ce6d743cad..49887f9e0d 100644
--- a/src/test/java/rx/schedulers/SchedulerLifecycleTest.java
+++ b/src/test/java/rx/schedulers/SchedulerLifecycleTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.schedulers;
 
 import static org.junit.Assert.*;
diff --git a/src/test/java/rx/schedulers/SchedulerTests.java b/src/test/java/rx/schedulers/SchedulerTests.java
index cd1d0a1912..3a6bb8d632 100644
--- a/src/test/java/rx/schedulers/SchedulerTests.java
+++ b/src/test/java/rx/schedulers/SchedulerTests.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.schedulers;
 
 import rx.CapturingUncaughtExceptionHandler;

From 4165091b0093ebe9e4c7419e5f434252c07c3619 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 29 Apr 2016 22:42:32 +0200
Subject: [PATCH 008/263] 1.x: OperatorMapPair should unsubscribe on crash
 eagerly (#3896)

---
 .../internal/operators/OperatorMapPair.java   | 106 +++++++++++++-----
 .../operators/OperatorMapPairTest.java        |  39 +++++++
 2 files changed, 117 insertions(+), 28 deletions(-)
 create mode 100644 src/test/java/rx/internal/operators/OperatorMapPairTest.java

diff --git a/src/main/java/rx/internal/operators/OperatorMapPair.java b/src/main/java/rx/internal/operators/OperatorMapPair.java
index b16a9b3c41..3cba7d6bf8 100644
--- a/src/main/java/rx/internal/operators/OperatorMapPair.java
+++ b/src/main/java/rx/internal/operators/OperatorMapPair.java
@@ -15,12 +15,11 @@
  */
 package rx.internal.operators;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.Operator;
 import rx.exceptions.*;
-import rx.Subscriber;
-import rx.functions.Func1;
-import rx.functions.Func2;
+import rx.functions.*;
+import rx.internal.util.RxJavaPluginUtils;
 
 /**
  * An {@link Operator} that pairs up items emitted by a source {@link Observable} with the sequence of items
@@ -45,6 +44,7 @@ public final class OperatorMapPair<T, U, R> implements Operator<Observable<? ext
      */
     public static <T, U> Func1<T, Observable<U>> convertSelector(final Func1<? super T, ? extends Iterable<? extends U>> selector) {
         return new Func1<T, Observable<U>>() {
+            @SuppressWarnings("cast")
             @Override
             public Observable<U> call(T t1) {
                 return (Observable<U>)Observable.from(selector.call(t1));
@@ -62,34 +62,84 @@ public OperatorMapPair(final Func1<? super T, ? extends Observable<? extends U>>
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super Observable<? extends R>> o) {
-        return new Subscriber<T>(o) {
+        MapPairSubscriber<T, U, R> parent = new MapPairSubscriber<T, U, R>(o, collectionSelector, resultSelector);
+        o.add(parent);
+        return parent;
+    }
+    
+    static final class MapPairSubscriber<T, U, R> extends Subscriber<T> {
+        
+        final Subscriber<? super Observable<? extends R>> actual;
+        
+        final Func1<? super T, ? extends Observable<? extends U>> collectionSelector;
+        final Func2<? super T, ? super U, ? extends R> resultSelector;
 
-            @Override
-            public void onCompleted() {
-                o.onCompleted();
+        boolean done;
+        
+        public MapPairSubscriber(Subscriber<? super Observable<? extends R>> actual, 
+                Func1<? super T, ? extends Observable<? extends U>> collectionSelector,
+                        Func2<? super T, ? super U, ? extends R> resultSelector) {
+            this.actual = actual;
+            this.collectionSelector = collectionSelector;
+            this.resultSelector = resultSelector;
+        }
+        
+        @Override
+        public void onNext(T outer) {
+            
+            Observable<? extends U> intermediate;
+            
+            try {
+                intermediate = collectionSelector.call(outer);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                onError(OnErrorThrowable.addValueAsLastCause(ex, outer));
+                return;
             }
-
-            @Override
-            public void onError(Throwable e) {
-                o.onError(e);
+            
+            actual.onNext(intermediate.map(new OuterInnerMapper<T, U, R>(outer, resultSelector)));
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            if (done) {
+                RxJavaPluginUtils.handleException(e);
+                return;
             }
-
-            @Override
-            public void onNext(final T outer) {
-                try {
-                    o.onNext(collectionSelector.call(outer).map(new Func1<U, R>() {
-
-                        @Override
-                        public R call(U inner) {
-                            return resultSelector.call(outer, inner);
-                        }
-                    }));
-                } catch (Throwable e) {
-                    Exceptions.throwOrReport(e, o, outer);
-                }
+            done = true;
+            
+            actual.onError(e);
+        }
+        
+        
+        @Override
+        public void onCompleted() {
+            if (done) {
+                return;
             }
-
-        };
+            actual.onCompleted();
+        }
+        
+        @Override
+        public void setProducer(Producer p) {
+            actual.setProducer(p);
+        }
     }
 
+    static final class OuterInnerMapper<T, U, R> implements Func1<U, R> {
+        final T outer;
+        final Func2<? super T, ? super U, ? extends R> resultSelector;
+
+        public OuterInnerMapper(T outer, Func2<? super T, ? super U, ? extends R> resultSelector) {
+            this.outer = outer;
+            this.resultSelector = resultSelector;
+        }
+        
+        @Override
+        public R call(U inner) {
+            return resultSelector.call(outer, inner);
+        }
+       
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/internal/operators/OperatorMapPairTest.java b/src/test/java/rx/internal/operators/OperatorMapPairTest.java
new file mode 100644
index 0000000000..2554b5e2f3
--- /dev/null
+++ b/src/test/java/rx/internal/operators/OperatorMapPairTest.java
@@ -0,0 +1,39 @@
+package rx.internal.operators;
+
+import org.junit.*;
+
+import rx.Observable;
+import rx.exceptions.TestException;
+import rx.functions.*;
+import rx.observers.TestSubscriber;
+import rx.subjects.PublishSubject;
+
+public class OperatorMapPairTest {
+    @Test
+    public void castCrashUnsubscribes() {
+        
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        ps.flatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer t) {
+                throw new TestException();
+            }
+        }, new Func2<Integer, Integer, Integer>() {
+            @Override
+            public Integer call(Integer t1, Integer t2) {
+                return t1;
+            }
+        }).unsafeSubscribe(ts);
+        
+        Assert.assertTrue("Not subscribed?", ps.hasObservers());
+        
+        ps.onNext(1);
+        
+        Assert.assertFalse("Subscribed?", ps.hasObservers());
+        
+        ts.assertError(TestException.class);
+    }
+}

From 35b51b327ae8f821609d103079d85d0373c675e6 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 29 Apr 2016 22:42:49 +0200
Subject: [PATCH 009/263] 1.x: cast() should unsubscribe on crash eagerly
 (#3895)

---
 .../rx/internal/operators/OperatorCast.java   | 74 ++++++++++++++-----
 .../internal/operators/OperatorCastTest.java  | 30 ++++++--
 2 files changed, 79 insertions(+), 25 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorCast.java b/src/main/java/rx/internal/operators/OperatorCast.java
index 825847b5ce..02099f31ad 100644
--- a/src/main/java/rx/internal/operators/OperatorCast.java
+++ b/src/main/java/rx/internal/operators/OperatorCast.java
@@ -15,9 +15,10 @@
  */
 package rx.internal.operators;
 
+import rx.*;
 import rx.Observable.Operator;
 import rx.exceptions.*;
-import rx.Subscriber;
+import rx.internal.util.RxJavaPluginUtils;
 
 /**
  * Converts the elements of an observable sequence to the specified type.
@@ -32,26 +33,63 @@ public OperatorCast(Class<R> castClass) {
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super R> o) {
-        return new Subscriber<T>(o) {
+        CastSubscriber<T, R> parent = new CastSubscriber<T, R>(o, castClass);
+        o.add(parent);
+        return parent;
+    }
+    
+    static final class CastSubscriber<T, R> extends Subscriber<T> {
+        
+        final Subscriber<? super R> actual;
+        
+        final Class<R> castClass;
 
-            @Override
-            public void onCompleted() {
-                o.onCompleted();
+        boolean done;
+        
+        public CastSubscriber(Subscriber<? super R> actual, Class<R> castClass) {
+            this.actual = actual;
+            this.castClass = castClass;
+        }
+        
+        @Override
+        public void onNext(T t) {
+            R result;
+            
+            try {
+                result = castClass.cast(t);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                onError(OnErrorThrowable.addValueAsLastCause(ex, t));
+                return;
             }
-
-            @Override
-            public void onError(Throwable e) {
-                o.onError(e);
+            
+            actual.onNext(result);
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            if (done) {
+                RxJavaPluginUtils.handleException(e);
+                return;
             }
-
-            @Override
-            public void onNext(T t) {
-                try {
-                    o.onNext(castClass.cast(t));
-                } catch (Throwable e) {
-                    Exceptions.throwOrReport(e, this, t);
-                }
+            done = true;
+            
+            actual.onError(e);
+        }
+        
+        
+        @Override
+        public void onCompleted() {
+            if (done) {
+                return;
             }
-        };
+            actual.onCompleted();
+        }
+        
+        @Override
+        public void setProducer(Producer p) {
+            actual.setProducer(p);
+        }
     }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorCastTest.java b/src/test/java/rx/internal/operators/OperatorCastTest.java
index 1f18b592c2..d67c1abfa4 100644
--- a/src/test/java/rx/internal/operators/OperatorCastTest.java
+++ b/src/test/java/rx/internal/operators/OperatorCastTest.java
@@ -15,15 +15,13 @@
  */
 package rx.internal.operators;
 
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import rx.Observable;
-import rx.Observer;
+import rx.*;
+import rx.observers.TestSubscriber;
+import rx.subjects.PublishSubject;
 
 public class OperatorCastTest {
 
@@ -53,4 +51,22 @@ public void testCastWithWrongType() {
         verify(observer, times(1)).onError(
                 org.mockito.Matchers.any(ClassCastException.class));
     }
+    
+    @Test
+    public void castCrashUnsubscribes() {
+        
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        TestSubscriber<String> ts = TestSubscriber.create();
+        
+        ps.cast(String.class).unsafeSubscribe(ts);
+        
+        Assert.assertTrue("Not subscribed?", ps.hasObservers());
+        
+        ps.onNext(1);
+        
+        Assert.assertFalse("Subscribed?", ps.hasObservers());
+        
+        ts.assertError(ClassCastException.class);
+    }
 }

From dec05b26eae8bdc0a6894d67de5662668a42d68c Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 29 Apr 2016 22:44:32 +0200
Subject: [PATCH 010/263] 1.x: map() and filter() should unsubscribe on crash
 eagerly (#3890)

---
 .../rx/internal/operators/OperatorFilter.java | 86 +++++++++++++------
 .../rx/internal/operators/OperatorMap.java    | 80 ++++++++++++-----
 .../operators/OperatorFilterTest.java         | 27 ++++++
 .../internal/operators/OperatorMapTest.java   | 46 ++++++----
 4 files changed, 179 insertions(+), 60 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorFilter.java b/src/main/java/rx/internal/operators/OperatorFilter.java
index 3704dbc4a3..15f1a48ec9 100644
--- a/src/main/java/rx/internal/operators/OperatorFilter.java
+++ b/src/main/java/rx/internal/operators/OperatorFilter.java
@@ -15,15 +15,17 @@
  */
 package rx.internal.operators;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Subscriber;
 import rx.exceptions.*;
 import rx.functions.Func1;
+import rx.internal.util.RxJavaPluginUtils;
 
 /**
  * Filters an Observable by discarding any items it emits that do not meet some test.
  * <p>
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/filter.png" alt="">
+ * @param <T> the value type
  */
 public final class OperatorFilter<T> implements Operator<T, T> {
 
@@ -35,33 +37,67 @@ public OperatorFilter(Func1<? super T, Boolean> predicate) {
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
-        return new Subscriber<T>(child) {
+        FilterSubscriber<T> parent = new FilterSubscriber<T>(child, predicate);
+        child.add(parent);
+        return parent;
+    }
 
-            @Override
-            public void onCompleted() {
-                child.onCompleted();
-            }
+    static final class FilterSubscriber<T> extends Subscriber<T> {
+        
+        final Subscriber<? super T> actual;
+        
+        final Func1<? super T, Boolean> predicate;
 
-            @Override
-            public void onError(Throwable e) {
-                child.onError(e);
+        boolean done;
+        
+        public FilterSubscriber(Subscriber<? super T> actual, Func1<? super T, Boolean> predicate) {
+            this.actual = actual;
+            this.predicate = predicate;
+        }
+        
+        @Override
+        public void onNext(T t) {
+            boolean result;
+            
+            try {
+                result = predicate.call(t);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                onError(OnErrorThrowable.addValueAsLastCause(ex, t));
+                return;
             }
-
-            @Override
-            public void onNext(T t) {
-                try {
-                    if (predicate.call(t)) {
-                        child.onNext(t);
-                    } else {
-                        // TODO consider a more complicated version that batches these
-                        request(1);
-                    }
-                } catch (Throwable e) {
-                    Exceptions.throwOrReport(e, child, t);
-                }
+            
+            if (result) {
+                actual.onNext(t);
+            } else {
+                request(1);
             }
-
-        };
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            if (done) {
+                RxJavaPluginUtils.handleException(e);
+                return;
+            }
+            done = true;
+            
+            actual.onError(e);
+        }
+        
+        
+        @Override
+        public void onCompleted() {
+            if (done) {
+                return;
+            }
+            actual.onCompleted();
+        }
+        @Override
+        public void setProducer(Producer p) {
+            super.setProducer(p);
+            actual.setProducer(p);
+        }
     }
-
 }
diff --git a/src/main/java/rx/internal/operators/OperatorMap.java b/src/main/java/rx/internal/operators/OperatorMap.java
index 90925c2764..a8a33178ca 100644
--- a/src/main/java/rx/internal/operators/OperatorMap.java
+++ b/src/main/java/rx/internal/operators/OperatorMap.java
@@ -15,16 +15,20 @@
  */
 package rx.internal.operators;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Subscriber;
-import rx.exceptions.Exceptions;
+import rx.exceptions.*;
 import rx.functions.Func1;
+import rx.internal.util.RxJavaPluginUtils;
 
 /**
  * Applies a function of your choosing to every item emitted by an {@code Observable}, and emits the results of
  * this transformation as a new {@code Observable}.
  * <p>
  * <img width="640" height="305" src="https://raw.githubusercontent.com/wiki/ReactiveX/RxJava/images/rx-operators/map.png" alt="">
+ * 
+ * @param <T> the input value type
+ * @param <R> the return value type
  */
 public final class OperatorMap<T, R> implements Operator<R, T> {
 
@@ -36,28 +40,64 @@ public OperatorMap(Func1<? super T, ? extends R> transformer) {
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super R> o) {
-        return new Subscriber<T>(o) {
+        MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
+        o.add(parent);
+        return parent;
+    }
+    
+    static final class MapSubscriber<T, R> extends Subscriber<T> {
+        
+        final Subscriber<? super R> actual;
+        
+        final Func1<? super T, ? extends R> mapper;
 
-            @Override
-            public void onCompleted() {
-                o.onCompleted();
+        boolean done;
+        
+        public MapSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
+            this.actual = actual;
+            this.mapper = mapper;
+        }
+        
+        @Override
+        public void onNext(T t) {
+            R result;
+            
+            try {
+                result = mapper.call(t);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                onError(OnErrorThrowable.addValueAsLastCause(ex, t));
+                return;
             }
-
-            @Override
-            public void onError(Throwable e) {
-                o.onError(e);
+            
+            actual.onNext(result);
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            if (done) {
+                RxJavaPluginUtils.handleException(e);
+                return;
             }
-
-            @Override
-            public void onNext(T t) {
-                try {
-                    o.onNext(transformer.call(t));
-                } catch (Throwable e) {
-                    Exceptions.throwOrReport(e, this, t);
-                }
+            done = true;
+            
+            actual.onError(e);
+        }
+        
+        
+        @Override
+        public void onCompleted() {
+            if (done) {
+                return;
             }
-
-        };
+            actual.onCompleted();
+        }
+        
+        @Override
+        public void setProducer(Producer p) {
+            actual.setProducer(p);
+        }
     }
 
 }
diff --git a/src/test/java/rx/internal/operators/OperatorFilterTest.java b/src/test/java/rx/internal/operators/OperatorFilterTest.java
index f1f086666c..543dc06cf7 100644
--- a/src/test/java/rx/internal/operators/OperatorFilterTest.java
+++ b/src/test/java/rx/internal/operators/OperatorFilterTest.java
@@ -28,6 +28,7 @@
 import rx.functions.*;
 import rx.internal.util.RxRingBuffer;
 import rx.observers.TestSubscriber;
+import rx.subjects.PublishSubject;
 
 public class OperatorFilterTest {
 
@@ -54,6 +55,7 @@ public Boolean call(String t1) {
 
     /**
      * Make sure we are adjusting subscriber.request() for filtered items
+     * @throws InterruptedException on interrupt
      */
     @Test(timeout = 500)
     public void testWithBackpressure() throws InterruptedException {
@@ -100,6 +102,7 @@ public void onNext(String t) {
 
     /**
      * Make sure we are adjusting subscriber.request() for filtered items
+     * @throws InterruptedException on interrupt
      */
     @Test(timeout = 500000)
     public void testWithBackpressure2() throws InterruptedException {
@@ -167,4 +170,28 @@ public void call(Integer t) {
             }
         }
     }
+
+    @Test
+    public void functionCrashUnsubscribes() {
+        
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        ps.filter(new Func1<Integer, Boolean>() {
+            @Override
+            public Boolean call(Integer v) { 
+                throw new TestException(); 
+            }
+        }).unsafeSubscribe(ts);
+        
+        Assert.assertTrue("Not subscribed?", ps.hasObservers());
+        
+        ps.onNext(1);
+        
+        Assert.assertFalse("Subscribed?", ps.hasObservers());
+        
+        ts.assertError(TestException.class);
+    }
+
 }
diff --git a/src/test/java/rx/internal/operators/OperatorMapTest.java b/src/test/java/rx/internal/operators/OperatorMapTest.java
index d79d5863b6..18e3e523e3 100644
--- a/src/test/java/rx/internal/operators/OperatorMapTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMapTest.java
@@ -16,28 +16,21 @@
 package rx.internal.operators;
 
 import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.*;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.NoSuchElementException;
+import java.util.*;
 
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.junit.*;
+import org.mockito.*;
 
 import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
-import rx.exceptions.OnErrorNotImplementedException;
-import rx.functions.Action1;
-import rx.functions.Func1;
-import rx.functions.Func2;
-import rx.internal.operators.OperatorMap;
+import rx.exceptions.*;
+import rx.functions.*;
+import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
+import rx.subjects.PublishSubject;
 
 public class OperatorMapTest {
 
@@ -339,4 +332,27 @@ public void call(String s) {
             }
         });
     }
+    
+    @Test
+    public void functionCrashUnsubscribes() {
+        
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        ps.map(new Func1<Integer, Integer>() {
+            @Override
+            public Integer call(Integer v) { 
+                throw new TestException(); 
+            }
+        }).unsafeSubscribe(ts);
+        
+        Assert.assertTrue("Not subscribed?", ps.hasObservers());
+        
+        ps.onNext(1);
+        
+        Assert.assertFalse("Subscribed?", ps.hasObservers());
+        
+        ts.assertError(TestException.class);
+    }
 }

From 1d7e88988f11cb55f1270c68ac70c4cdf8206897 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 29 Apr 2016 23:43:36 +0200
Subject: [PATCH 011/263] 1.x: fix multiple chained Single.doAfterTerminate not
 calling actions (#3883)

---
 src/main/java/rx/Single.java                  |  2 +-
 .../operators/SingleDoAfterTerminate.java     | 84 ++++++++++++++++
 .../operators/SingleDoAfterTerminateTest.java | 99 +++++++++++++++++++
 3 files changed, 184 insertions(+), 1 deletion(-)
 create mode 100644 src/main/java/rx/internal/operators/SingleDoAfterTerminate.java
 create mode 100644 src/test/java/rx/internal/operators/SingleDoAfterTerminateTest.java

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index e954612b4f..bba3555a55 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -2484,7 +2484,7 @@ public final Single<T> doOnUnsubscribe(final Action0 action) {
      */
     @Experimental
     public final Single<T> doAfterTerminate(Action0 action) {
-        return lift(new OperatorDoAfterTerminate<T>(action));
+        return create(new SingleDoAfterTerminate<T>(this, action));
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/SingleDoAfterTerminate.java b/src/main/java/rx/internal/operators/SingleDoAfterTerminate.java
new file mode 100644
index 0000000000..ea9986ebac
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleDoAfterTerminate.java
@@ -0,0 +1,84 @@
+/**
+ * Copyright 2015 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.exceptions.Exceptions;
+import rx.functions.Action0;
+import rx.internal.util.RxJavaPluginUtils;
+
+/**
+ * Execute an action after onSuccess or onError has been delivered.
+ *
+ * @param <T> the value type
+ */
+public final class SingleDoAfterTerminate<T> implements Single.OnSubscribe<T> {
+    final Single<T> source;
+    
+    final Action0 action;
+
+    public SingleDoAfterTerminate(Single<T> source, Action0 action) {
+        this.source = source;
+        this.action = action;
+    }
+    
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        SingleDoAfterTerminateSubscriber<T> parent = new SingleDoAfterTerminateSubscriber<T>(t, action);
+        t.add(parent);
+        source.subscribe(parent);
+    }
+    
+    static final class SingleDoAfterTerminateSubscriber<T> extends SingleSubscriber<T> {
+        final SingleSubscriber<? super T> actual;
+
+        final Action0 action;
+        
+        public SingleDoAfterTerminateSubscriber(SingleSubscriber<? super T> actual, Action0 action) {
+            this.actual = actual;
+            this.action = action;
+        }
+        
+        @Override
+        public void onSuccess(T value) {
+            try {
+                actual.onSuccess(value);
+            } finally {
+                doAction();
+            }
+        }
+        
+        @Override
+        public void onError(Throwable error) {
+            try {
+                actual.onError(error);
+            } finally {
+                doAction();
+            }
+        }
+        
+        void doAction() {
+            try {
+                action.call();
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                RxJavaPluginUtils.handleException(ex);
+            }
+        }
+    }
+    
+    
+}
diff --git a/src/test/java/rx/internal/operators/SingleDoAfterTerminateTest.java b/src/test/java/rx/internal/operators/SingleDoAfterTerminateTest.java
new file mode 100644
index 0000000000..be2ab6fb5d
--- /dev/null
+++ b/src/test/java/rx/internal/operators/SingleDoAfterTerminateTest.java
@@ -0,0 +1,99 @@
+/**
+ * Copyright 2015 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.*;
+
+import rx.Single;
+import rx.functions.*;
+import rx.observers.TestSubscriber;
+
+public class SingleDoAfterTerminateTest {
+
+    @Test
+    public void chainedCallsOuter() {
+        for (int i = 2; i <= 5; i++) {
+            final AtomicInteger counter = new AtomicInteger();
+            
+            Single<String> source = Single.just("Test")
+            .flatMap(new Func1<String, Single<String>>() {
+                @Override
+                public Single<String> call(String s) {
+                    return Single.just("Test2")
+                        .doAfterTerminate(new Action0() {
+                            @Override
+                            public void call() {
+                                counter.getAndIncrement();
+                            }
+                        });
+                }
+            }
+            );
+            Single<String> result = source;
+
+            for (int j = 1; j < i; j++) {
+                result = result.doAfterTerminate(new Action0() {
+                    @Override
+                    public void call() {
+                        counter.getAndIncrement();
+                    }
+                });
+            }
+            
+            result
+            .subscribe(new TestSubscriber<String>());
+            
+            Assert.assertEquals(i, counter.get());
+        }
+    }
+    
+    @Test
+    public void chainedCallsInner() {
+        for (int i = 2; i <= 5; i++) {
+            final AtomicInteger counter = new AtomicInteger();
+            
+            final int fi = i;
+            
+            Single.just("Test")
+            .flatMap(new Func1<String, Single<String>>() {
+                @Override
+                public Single<String> call(String s) {
+                    Single<String> result = Single.just("Test2");
+                    for (int j = 1; j < fi; j++) {
+                        result = result.doAfterTerminate(new Action0() {
+                            @Override
+                            public void call() {
+                                counter.getAndIncrement();
+                            }
+                        });
+                    }
+                    return result;
+                }
+            })
+            .doAfterTerminate(new Action0() {
+                @Override
+                public void call() {
+                    counter.getAndIncrement();
+                }
+            })
+            .subscribe(new TestSubscriber<String>());
+            
+            Assert.assertEquals(i, counter.get());
+        }
+    }
+}

From d82f1be8ce4b4c1b0af640db5884d47899659b27 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 29 Apr 2016 23:43:52 +0200
Subject: [PATCH 012/263] 1.x: enable backpressure with from(Future). (#3893)

---
 .../OnSubscribeToObservableFuture.java        |  4 +-
 .../OnSubscribeToObservableFutureTest.java    | 47 ++++++++++++-------
 2 files changed, 32 insertions(+), 19 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java b/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
index 0f6e2e3f76..573c4065cd 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
@@ -22,6 +22,7 @@
 import rx.exceptions.Exceptions;
 import rx.Subscriber;
 import rx.functions.Action0;
+import rx.internal.producers.SingleProducer;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -72,8 +73,7 @@ public void call() {
                     return;
                 }
                 T value = (unit == null) ? (T) that.get() : (T) that.get(time, unit);
-                subscriber.onNext(value);
-                subscriber.onCompleted();
+                subscriber.setProducer(new SingleProducer<T>(subscriber, value));
             } catch (Throwable e) {
                 // If this Observable is unsubscribed, we will receive an CancellationException.
                 // However, CancellationException will not be passed to the final Subscriber
diff --git a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
index ff37d8fab3..4740b97aa0 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
@@ -16,27 +16,16 @@
 package rx.internal.operators;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.*;
+
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 
-import rx.Observable;
-import rx.Observer;
-import rx.Subscription;
-import rx.observers.TestObserver;
-import rx.observers.TestSubscriber;
+import rx.*;
+import rx.observers.*;
 import rx.schedulers.Schedulers;
 
 public class OnSubscribeToObservableFutureTest {
@@ -139,4 +128,28 @@ public Object get(long timeout, TimeUnit unit) throws InterruptedException, Exec
         assertEquals(0, testSubscriber.getOnCompletedEvents().size());
         assertEquals(0, testSubscriber.getOnNextEvents().size());
     }
+    
+    @Test
+    public void backpressure() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
+        
+        FutureTask<Integer> f = new FutureTask<Integer>(new Runnable() {
+            @Override
+            public void run() {
+                
+            }
+        }, 1);
+        
+        f.run();
+        
+        Observable.from(f).subscribe(ts);
+        
+        ts.assertNoValues();
+        
+        ts.requestMore(1);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }

From 2bf53a9a3c6ddd9051a50fdbf9600a2e585f7a35 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Zsombor=20Erd=C5=91dy-Nagy?=
 <zsombor.erdody-nagy@skyscanner.net>
Date: Mon, 2 May 2016 07:25:29 +0200
Subject: [PATCH 013/263] Spare a few redundant calls in SleepingAction around
 determining the delay value (#3903)

- Remove redundant outer conditional.
- Skip calling into System.currentTimeMillis(), which could potentially result in different values.
---
 .../rx/internal/schedulers/SleepingAction.java  | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/main/java/rx/internal/schedulers/SleepingAction.java b/src/main/java/rx/internal/schedulers/SleepingAction.java
index c41c01caf0..e3bdeb16ba 100644
--- a/src/main/java/rx/internal/schedulers/SleepingAction.java
+++ b/src/main/java/rx/internal/schedulers/SleepingAction.java
@@ -34,15 +34,14 @@ public void call() {
         if (innerScheduler.isUnsubscribed()) {
             return;
         }
-        if (execTime > innerScheduler.now()) {
-            long delay = execTime - innerScheduler.now();
-            if (delay > 0) {
-                try {
-                    Thread.sleep(delay);
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                    throw new RuntimeException(e);
-                }
+
+        long delay = execTime - innerScheduler.now();
+        if (delay > 0) {
+            try {
+                Thread.sleep(delay);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new RuntimeException(e);
             }
         }
 

From 191f023cf5253ea90647bc091dcaf55ccdce81cc Mon Sep 17 00:00:00 2001
From: Prat <prt2121@users.noreply.github.com>
Date: Mon, 2 May 2016 03:08:41 -0400
Subject: [PATCH 014/263] 1.x: Fix Completable swallows
 OnErrorNotImplementedException (#3904)

---
 src/main/java/rx/Completable.java     |  1 +
 src/test/java/rx/CompletableTest.java | 24 ++++++++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 1fc39fbfda..8a2a4121d2 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -1972,6 +1972,7 @@ public final void subscribe(CompletableSubscriber s) {
             throw ex;
         } catch (Throwable ex) {
             ERROR_HANDLER.handleError(ex);
+            Exceptions.throwIfFatal(ex);
             throw toNpe(ex);
         }
     }
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 2493da2356..8ee2f747d3 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -2813,6 +2813,30 @@ public void call() {
         });
     }
 
+    @Test(expected = OnErrorNotImplementedException.class)
+    public void propagateExceptionSubscribeEmpty() {
+        error.completable.toSingleDefault(0).subscribe();
+    }
+
+    @Test(expected = OnErrorNotImplementedException.class)
+    public void propagateExceptionSubscribeOneAction() {
+        error.completable.toSingleDefault(1).subscribe(new Action1<Integer>() {
+            @Override
+            public void call(Integer integer) {
+            }
+        });
+    }
+
+    @Test(expected = OnErrorNotImplementedException.class)
+    public void propagateExceptionSubscribeOneActionThrowFromOnSuccess() {
+        normal.completable.toSingleDefault(1).subscribe(new Action1<Integer>() {
+            @Override
+            public void call(Integer integer) {
+                throw new TestException();
+            }
+        });
+    }
+
     @Test(timeout = 1000)
     public void timeoutEmitError() {
         Throwable e = Completable.never().timeout(100, TimeUnit.MILLISECONDS).get();

From 4f2271d1231c9fbbcd36f7f30318e2373468ffc4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Zsombor=20Erd=C5=91dy-Nagy?=
 <zsombor.erdody-nagy@skyscanner.net>
Date: Mon, 2 May 2016 19:03:38 +0200
Subject: [PATCH 015/263] Small code style consistency fix for
 WeakSingleProducer (#3901)

- Handling the case of 0 requests with the same style as SingleDelayedProducer and SingleProducer.
---
 .../util/ScalarSynchronousObservable.java     | 37 ++++++++++---------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
index ecb5c18d98..ca6ba3f437 100644
--- a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
+++ b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
@@ -255,25 +255,26 @@ public void request(long n) {
             if (n < 0L) {
                 throw new IllegalStateException("n >= required but it was " + n);
             }
-            if (n != 0L) {
-                once = true;
-                Subscriber<? super T> a = actual;
-                if (a.isUnsubscribed()) {
-                    return;
-                }
-                T v = value;
-                try {
-                    a.onNext(v);
-                } catch (Throwable e) {
-                    Exceptions.throwOrReport(e, a, v);
-                    return;
-                }
-                
-                if (a.isUnsubscribed()) {
-                    return;
-                }
-                a.onCompleted();
+            if (n == 0L) {
+                return;
+            }
+            once = true;
+            Subscriber<? super T> a = actual;
+            if (a.isUnsubscribed()) {
+                return;
+            }
+            T v = value;
+            try {
+                a.onNext(v);
+            } catch (Throwable e) {
+                Exceptions.throwOrReport(e, a, v);
+                return;
             }
+
+            if (a.isUnsubscribed()) {
+                return;
+            }
+            a.onCompleted();
         }
     }
 }
\ No newline at end of file

From 3721666912bd4b76f308d48467192e02f7df2408 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Mon, 2 May 2016 23:04:01 +0200
Subject: [PATCH 016/263] 1.x: optimize merge/flatMap for empty sources (#3761)

---
 .../rx/internal/operators/OperatorMerge.java  |  13 +++
 .../operators/OperatorFlatMapTest.java        | 106 ++++++++++++++++++
 2 files changed, 119 insertions(+)

diff --git a/src/main/java/rx/internal/operators/OperatorMerge.java b/src/main/java/rx/internal/operators/OperatorMerge.java
index d0bbf38a24..1f7f95d2ef 100644
--- a/src/main/java/rx/internal/operators/OperatorMerge.java
+++ b/src/main/java/rx/internal/operators/OperatorMerge.java
@@ -237,6 +237,9 @@ public void onNext(Observable<? extends T> t) {
             if (t == null) {
                 return;
             }
+            if (t == Observable.empty()) {
+                emitEmpty();
+            } else
             if (t instanceof ScalarSynchronousObservable) {
                 tryEmit(((ScalarSynchronousObservable<? extends T>)t).get());
             } else {
@@ -247,6 +250,16 @@ public void onNext(Observable<? extends T> t) {
             }
         }
         
+        void emitEmpty() {
+            int produced = scalarEmissionCount + 1;
+            if (produced == scalarEmissionLimit) {
+                scalarEmissionCount = 0;
+                this.requestMore(produced);
+            } else {
+                scalarEmissionCount = produced;
+            }
+        }
+        
         private void reportError() {
             List<Throwable> list = new ArrayList<Throwable>(errors);
             if (list.size() == 1) {
diff --git a/src/test/java/rx/internal/operators/OperatorFlatMapTest.java b/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
index 56d733affd..8213252c85 100644
--- a/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
+++ b/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
@@ -29,6 +29,7 @@
 import rx.Observer;
 import rx.exceptions.TestException;
 import rx.functions.*;
+import rx.internal.util.RxRingBuffer;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 
@@ -544,4 +545,109 @@ public Observable<Integer> call(Integer t) {
             ts.assertValueCount(n * 2);
         }
     }
+    
+    @Test
+    public void justEmptyMixture() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(0, 4 * RxRingBuffer.SIZE)
+        .flatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return (v & 1) == 0 ? Observable.<Integer>empty() : Observable.just(v);
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValueCount(2 * RxRingBuffer.SIZE);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+        int j = 1;
+        for (Integer v : ts.getOnNextEvents()) {
+            Assert.assertEquals(j, v.intValue());
+            
+            j += 2;
+        }
+    }
+
+    @Test
+    public void rangeEmptyMixture() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(0, 4 * RxRingBuffer.SIZE)
+        .flatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return (v & 1) == 0 ? Observable.<Integer>empty() : Observable.range(v, 2);
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValueCount(4 * RxRingBuffer.SIZE);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+        int j = 1;
+        List<Integer> list = ts.getOnNextEvents();
+        for (int i = 0; i < list.size(); i += 2) {
+            Assert.assertEquals(j, list.get(i).intValue());
+            Assert.assertEquals(j + 1, list.get(i + 1).intValue());
+            
+            j += 2;
+        }
+    }
+
+    @Test
+    public void justEmptyMixtureMaxConcurrent() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(0, 4 * RxRingBuffer.SIZE)
+        .flatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return (v & 1) == 0 ? Observable.<Integer>empty() : Observable.just(v);
+            }
+        }, 16)
+        .subscribe(ts);
+        
+        ts.assertValueCount(2 * RxRingBuffer.SIZE);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+        int j = 1;
+        for (Integer v : ts.getOnNextEvents()) {
+            Assert.assertEquals(j, v.intValue());
+            
+            j += 2;
+        }
+    }
+
+    @Test
+    public void rangeEmptyMixtureMaxConcurrent() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(0, 4 * RxRingBuffer.SIZE)
+        .flatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return (v & 1) == 0 ? Observable.<Integer>empty() : Observable.range(v, 2);
+            }
+        }, 16)
+        .subscribe(ts);
+        
+        ts.assertValueCount(4 * RxRingBuffer.SIZE);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+        int j = 1;
+        List<Integer> list = ts.getOnNextEvents();
+        for (int i = 0; i < list.size(); i += 2) {
+            Assert.assertEquals(j, list.get(i).intValue());
+            Assert.assertEquals(j + 1, list.get(i + 1).intValue());
+            
+            j += 2;
+        }
+    }
+
 }

From 04ef4e6faadfa1475e26d9c61f74d2e6293a3d06 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 3 May 2016 00:50:48 +0200
Subject: [PATCH 017/263] 1.x: fix singleOrDefault() backpressure if source is
 empty (#3905)

Issue #3892 is a goldmine for missing backpressure problems. This PR fixes the case when singleOrDefault encounters an empty source and has to emit some default value. Fixed via setting the SingleProducer on the child on termination.
---
 .../rx/internal/operators/OperatorSingle.java | 40 +++++++------------
 .../operators/OperatorSingleTest.java         | 16 ++++++++
 2 files changed, 31 insertions(+), 25 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorSingle.java b/src/main/java/rx/internal/operators/OperatorSingle.java
index 252b6c4ac3..f8415b9a20 100644
--- a/src/main/java/rx/internal/operators/OperatorSingle.java
+++ b/src/main/java/rx/internal/operators/OperatorSingle.java
@@ -16,11 +16,11 @@
 package rx.internal.operators;
 
 import java.util.NoSuchElementException;
-import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.Observable.Operator;
-import rx.Producer;
 import rx.Subscriber;
+import rx.internal.producers.SingleProducer;
+import rx.internal.util.RxJavaPluginUtils;
 
 /**
  * If the Observable completes after emitting a single item that matches a
@@ -65,19 +65,6 @@ public Subscriber<? super T> call(final Subscriber<? super T> child) {
 
         final ParentSubscriber<T> parent = new ParentSubscriber<T>(child, hasDefaultValue,
                 defaultValue);
-
-        child.setProducer(new Producer() {
-
-            private final AtomicBoolean requestedTwo = new AtomicBoolean(false);
-
-            @Override
-            public void request(long n) {
-                if (n > 0 && requestedTwo.compareAndSet(false, true)) {
-                    parent.requestMore(2);
-                }
-            }
-
-        });
         child.add(parent);
         return parent;
     }
@@ -88,8 +75,8 @@ private static final class ParentSubscriber<T> extends Subscriber<T> {
         private final T defaultValue;
         
         private T value;
-        private boolean isNonEmpty = false;
-        private boolean hasTooManyElements = false;
+        private boolean isNonEmpty;
+        private boolean hasTooManyElements;
 
         
         ParentSubscriber(Subscriber<? super T> child, boolean hasDefaultValue,
@@ -97,14 +84,14 @@ private static final class ParentSubscriber<T> extends Subscriber<T> {
             this.child = child;
             this.hasDefaultValue = hasDefaultValue;
             this.defaultValue = defaultValue;
-        }
-
-        void requestMore(long n) {
-            request(n);
+            request(2); // could go unbounded, but test expect this
         }
 
         @Override
         public void onNext(T value) {
+            if (hasTooManyElements) {
+                return;
+            } else
             if (isNonEmpty) {
                 hasTooManyElements = true;
                 child.onError(new IllegalArgumentException("Sequence contains too many elements"));
@@ -121,12 +108,10 @@ public void onCompleted() {
                 // We have already sent an onError message
             } else {
                 if (isNonEmpty) {
-                    child.onNext(value);
-                    child.onCompleted();
+                    child.setProducer(new SingleProducer<T>(child, value));
                 } else {
                     if (hasDefaultValue) {
-                        child.onNext(defaultValue);
-                        child.onCompleted();
+                        child.setProducer(new SingleProducer<T>(child, defaultValue));
                     } else {
                         child.onError(new NoSuchElementException("Sequence contains no elements"));
                     }
@@ -136,6 +121,11 @@ public void onCompleted() {
 
         @Override
         public void onError(Throwable e) {
+            if (hasTooManyElements) {
+                RxJavaPluginUtils.handleException(e);
+                return;
+            }
+            
             child.onError(e);
         }
 
diff --git a/src/test/java/rx/internal/operators/OperatorSingleTest.java b/src/test/java/rx/internal/operators/OperatorSingleTest.java
index f1490e8910..9bdd630c5d 100644
--- a/src/test/java/rx/internal/operators/OperatorSingleTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSingleTest.java
@@ -37,6 +37,7 @@
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.functions.Func2;
+import rx.observers.TestSubscriber;
 
 public class OperatorSingleTest {
 
@@ -456,4 +457,19 @@ public Integer call(Integer i1, Integer i2) {
         Integer r = reduced.toBlocking().first();
         assertEquals(21, r.intValue());
     }
+    
+    @Test
+    public void defaultBackpressure() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        
+        Observable.<Integer>empty().singleOrDefault(1).subscribe(ts);
+        
+        ts.assertNoValues();
+        
+        ts.requestMore(1);
+        
+        ts.assertValue(1);
+        ts.assertCompleted();
+        ts.assertNoErrors();
+    }
 }

From 4e5c17c6186db52f3440fa88c70b81448712b36d Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 3 May 2016 22:12:02 +0200
Subject: [PATCH 018/263] 1.x: proposal: onTerminateDetach - detach
 upstream/downstream for GC (#3888)

---
 src/main/java/rx/Observable.java              |  17 ++
 .../internal/operators/OnSubscribeDetach.java | 173 ++++++++++++++++++
 .../operators/OnSubscribeDetachTest.java      | 160 ++++++++++++++++
 3 files changed, 350 insertions(+)
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeDetach.java
 create mode 100644 src/test/java/rx/internal/operators/OnSubscribeDetachTest.java

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 1ca8527d23..0f7d39ece5 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -6611,6 +6611,23 @@ public final Observable<T> onExceptionResumeNext(final Observable<? extends T> r
         return lift((Operator<T, T>)OperatorOnErrorResumeNextViaFunction.withException(resumeSequence));
     }
 
+    
+    /**
+     * Nulls out references to the upstream producer and downstream Subscriber if
+     * the sequence is terminated or downstream unsubscribes.
+     * <dl>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code onTerminateDetach} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @return an Observable which out references to the upstream producer and downstream Subscriber if
+     * the sequence is terminated or downstream unsubscribes
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final Observable<T> onTerminateDetach() {
+        return create(new OnSubscribeDetach<T>(this));
+    }
+    
     /**
      * Returns a {@link ConnectableObservable}, which is a variety of Observable that waits until its
      * {@link ConnectableObservable#connect connect} method is called before it begins emitting items to those
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDetach.java b/src/main/java/rx/internal/operators/OnSubscribeDetach.java
new file mode 100644
index 0000000000..e736583c85
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeDetach.java
@@ -0,0 +1,173 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.atomic.*;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.internal.util.RxJavaPluginUtils;
+
+/**
+ * Nulls out references to upstream data structures when the source terminates or 
+ * the child unsubscribes.
+ * @param <T> the value type
+ */
+public final class OnSubscribeDetach<T> implements OnSubscribe<T> {
+    
+    final Observable<T> source;
+    
+    public OnSubscribeDetach(Observable<T> source) {
+        this.source = source;
+    }
+    
+    @Override
+    public void call(Subscriber<? super T> t) {
+        DetachSubscriber<T> parent = new DetachSubscriber<T>(t);
+        DetachProducer<T> producer = new DetachProducer<T>(parent);
+        
+        t.add(producer);
+        t.setProducer(producer);
+        
+        source.unsafeSubscribe(parent);
+    }
+    
+    /**
+     * The parent subscriber that forwards events and cleans up on a terminal state.
+     * @param <T> the value type
+     */
+    static final class DetachSubscriber<T> extends Subscriber<T> {
+        
+        final AtomicReference<Subscriber<? super T>> actual;
+        
+        final AtomicReference<Producer> producer;
+        
+        final AtomicLong requested;
+
+        public DetachSubscriber(Subscriber<? super T> actual) {
+            this.actual = new AtomicReference<Subscriber<? super T>>(actual);
+            this.producer = new AtomicReference<Producer>();
+            this.requested = new AtomicLong();
+        }
+        
+        @Override
+        public void onNext(T t) {
+            Subscriber<? super T> a = actual.get();
+            
+            if (a != null) {
+                a.onNext(t);
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            producer.lazySet(TerminatedProducer.INSTANCE);
+            Subscriber<? super T> a = actual.getAndSet(null);
+            
+            if (a != null) {
+                a.onError(e);
+            } else {
+                RxJavaPluginUtils.handleException(e);
+            }
+        }
+
+        
+        @Override
+        public void onCompleted() {
+            producer.lazySet(TerminatedProducer.INSTANCE);
+            Subscriber<? super T> a = actual.getAndSet(null);
+            
+            if (a != null) {
+                a.onCompleted();
+            }
+        }
+        
+        void innerRequest(long n) {
+            if (n < 0L) {
+                throw new IllegalArgumentException("n >= 0 required but it was " + n);
+            }
+            Producer p = producer.get();
+            if (p != null) {
+                p.request(n);
+            } else {
+                BackpressureUtils.getAndAddRequest(requested, n);
+                p = producer.get();
+                if (p != null && p != TerminatedProducer.INSTANCE) {
+                    long r = requested.getAndSet(0L);
+                    p.request(r);
+                }
+            }
+        }
+        
+        @Override
+        public void setProducer(Producer p) {
+            if (producer.compareAndSet(null, p)) {
+                long r = requested.getAndSet(0L);
+                p.request(r);
+            } else {
+                if (producer.get() != TerminatedProducer.INSTANCE) {
+                    throw new IllegalStateException("Producer already set!");
+                }
+            }
+        }
+        
+        void innerUnsubscribe() {
+            producer.lazySet(TerminatedProducer.INSTANCE);
+            actual.lazySet(null);
+            // full barrier in unsubscribe()
+            unsubscribe();
+        }
+    }
+    
+    /**
+     * Callbacks from the child Subscriber.
+     * @param <T> the value type
+     */
+    static final class DetachProducer<T> implements Producer, Subscription {
+        final DetachSubscriber<T> parent;
+
+        public DetachProducer(DetachSubscriber<T> parent) {
+            this.parent = parent;
+        }
+        
+        @Override
+        public void request(long n) {
+            parent.innerRequest(n);
+        }
+        
+        @Override
+        public boolean isUnsubscribed() {
+            return parent.isUnsubscribed();
+        }
+        
+        @Override
+        public void unsubscribe() {
+            parent.innerUnsubscribe();
+        }
+    }
+    
+    /**
+     * Singleton instance via enum.
+     */
+    enum TerminatedProducer implements Producer {
+        INSTANCE;
+        
+        @Override
+        public void request(long n) {
+            // ignored
+        }
+    }
+}
diff --git a/src/test/java/rx/internal/operators/OnSubscribeDetachTest.java b/src/test/java/rx/internal/operators/OnSubscribeDetachTest.java
new file mode 100644
index 0000000000..6257e4d227
--- /dev/null
+++ b/src/test/java/rx/internal/operators/OnSubscribeDetachTest.java
@@ -0,0 +1,160 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import java.lang.ref.WeakReference;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.*;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.exceptions.TestException;
+import rx.observers.TestSubscriber;
+
+public class OnSubscribeDetachTest {
+
+    Object o;
+    
+    @Test
+    public void just() throws Exception {
+        o = new Object();
+        
+        WeakReference<Object> wr = new WeakReference<Object>(o);
+        
+        TestSubscriber<Object> ts = new TestSubscriber<Object>();
+        
+        Observable.just(o).count().onTerminateDetach().subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertCompleted();
+        ts.assertNoErrors();
+        
+        o = null;
+        
+        System.gc();
+        Thread.sleep(200);
+        
+        Assert.assertNull("Object retained!", wr.get());
+        
+    }
+    
+    @Test
+    public void error() {
+        TestSubscriber<Object> ts = new TestSubscriber<Object>();
+        
+        Observable.error(new TestException()).onTerminateDetach().subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void empty() {
+        TestSubscriber<Object> ts = new TestSubscriber<Object>();
+        
+        Observable.empty().onTerminateDetach().subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void range() {
+        TestSubscriber<Object> ts = new TestSubscriber<Object>();
+        
+        Observable.range(1, 1000).onTerminateDetach().subscribe(ts);
+        
+        ts.assertValueCount(1000);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    
+    @Test
+    public void backpressured() throws Exception {
+        o = new Object();
+        
+        WeakReference<Object> wr = new WeakReference<Object>(o);
+        
+        TestSubscriber<Object> ts = new TestSubscriber<Object>(0L);
+        
+        Observable.just(o).count().onTerminateDetach().subscribe(ts);
+
+        ts.assertNoValues();
+
+        ts.requestMore(1);
+        
+        ts.assertValue(1);
+        ts.assertCompleted();
+        ts.assertNoErrors();
+        
+        o = null;
+        
+        System.gc();
+        Thread.sleep(200);
+        
+        Assert.assertNull("Object retained!", wr.get());
+    }
+
+    @Test
+    public void justUnsubscribed() throws Exception {
+        o = new Object();
+        
+        WeakReference<Object> wr = new WeakReference<Object>(o);
+        
+        TestSubscriber<Object> ts = new TestSubscriber<Object>(0);
+        
+        Observable.just(o).count().onTerminateDetach().subscribe(ts);
+        
+        ts.unsubscribe();
+        o = null;
+        
+        System.gc();
+        Thread.sleep(200);
+        
+        Assert.assertNull("Object retained!", wr.get());
+        
+    }
+
+    @Test
+    public void deferredUpstreamProducer() {
+        final AtomicReference<Subscriber<? super Object>> subscriber = new AtomicReference<Subscriber<? super Object>>();
+        
+        TestSubscriber<Object> ts = new TestSubscriber<Object>(0);
+        
+        Observable.create(new OnSubscribe<Object>() {
+            @Override
+            public void call(Subscriber<? super Object> t) {
+                subscriber.set(t);
+            }
+        }).onTerminateDetach().subscribe(ts);
+        
+        ts.requestMore(2);
+        
+        new OnSubscribeRange(1, 3).call(subscriber.get());
+        
+        ts.assertValues(1, 2);
+        
+        ts.requestMore(1);
+        
+        ts.assertValues(1, 2, 3);
+        ts.assertCompleted();
+        ts.assertNoErrors();
+    }
+}

From f2ed0797796a4961c8da12c2b3a48d9732ca56f9 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 3 May 2016 22:18:49 +0200
Subject: [PATCH 019/263] 1.x: optimize concatMapIterable/flatMapIterable
 (#3864)

* 1.x: optimize concatMapIterable/flatMapIterable

* Reformat else if
---
 src/main/java/rx/Observable.java              |   6 +-
 .../operators/OnSubscribeFlattenIterable.java | 357 +++++++++++++
 .../operators/OnSubscribeFromIterable.java    |   2 +-
 .../OnSubscribeFlattenIterableTest.java       | 477 ++++++++++++++++++
 4 files changed, 838 insertions(+), 4 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
 create mode 100644 src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 0f7d39ece5..39c09ad477 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -4061,7 +4061,7 @@ public final <R> Observable<R> concatMapDelayError(Func1<? super T, ? extends Ob
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
      */
     public final <R> Observable<R> concatMapIterable(Func1<? super T, ? extends Iterable<? extends R>> collectionSelector) {
-        return concat(map(OperatorMapPair.convertSelector(collectionSelector)));
+        return OnSubscribeFlattenIterable.createFrom(this, collectionSelector, RxRingBuffer.SIZE);
     }
     
     /**
@@ -5672,7 +5672,7 @@ public final <U, R> Observable<R> flatMap(final Func1<? super T, ? extends Obser
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
      */
     public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterable<? extends R>> collectionSelector) {
-        return merge(map(OperatorMapPair.convertSelector(collectionSelector)));
+        return flatMapIterable(collectionSelector, RxRingBuffer.SIZE);
     }
 
     /**
@@ -5702,7 +5702,7 @@ public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterab
      */
     @Beta
     public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterable<? extends R>> collectionSelector, int maxConcurrent) {
-        return merge(map(OperatorMapPair.convertSelector(collectionSelector)), maxConcurrent);
+        return OnSubscribeFlattenIterable.createFrom(this, collectionSelector, maxConcurrent);
     }
     
     /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
new file mode 100644
index 0000000000..fb3b9f97bd
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
@@ -0,0 +1,357 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import java.util.*;
+import java.util.concurrent.atomic.*;
+
+import rx.*;
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.exceptions.*;
+import rx.functions.Func1;
+import rx.internal.util.*;
+import rx.internal.util.atomic.*;
+import rx.internal.util.unsafe.*;
+
+/**
+ * Flattens a sequence if Iterable sources, generated via a function, into a single sequence.
+ *
+ * @param <T> the input value type
+ * @param <R> the output value type
+ */
+public final class OnSubscribeFlattenIterable<T, R> implements OnSubscribe<R> {
+    
+    final Observable<? extends T> source;
+    
+    final Func1<? super T, ? extends Iterable<? extends R>> mapper;
+    
+    final int prefetch;
+    
+    /** Protected: use createFrom to handle source-dependent optimizations. */
+    protected OnSubscribeFlattenIterable(Observable<? extends T> source,
+            Func1<? super T, ? extends Iterable<? extends R>> mapper, int prefetch) {
+        this.source = source;
+        this.mapper = mapper;
+        this.prefetch = prefetch;
+    }
+    
+    @Override
+    public void call(Subscriber<? super R> t) {
+        final FlattenIterableSubscriber<T, R> parent = new FlattenIterableSubscriber<T, R>(t, mapper, prefetch);
+        
+        t.add(parent);
+        t.setProducer(new Producer() {
+            @Override
+            public void request(long n) {
+                parent.requestMore(n);
+            }
+        });
+        
+        source.unsafeSubscribe(parent);
+    }
+    
+    public static <T, R> Observable<R> createFrom(Observable<? extends T> source,
+            Func1<? super T, ? extends Iterable<? extends R>> mapper, int prefetch) {
+        if (source instanceof ScalarSynchronousObservable) {
+            T scalar = ((ScalarSynchronousObservable<? extends T>) source).get();
+            return Observable.create(new OnSubscribeScalarFlattenIterable<T, R>(scalar, mapper));
+        }
+        return Observable.create(new OnSubscribeFlattenIterable<T, R>(source, mapper, prefetch));
+    }
+    
+    static final class FlattenIterableSubscriber<T, R> extends Subscriber<T> {
+        final Subscriber<? super R> actual;
+        
+        final Func1<? super T, ? extends Iterable<? extends R>> mapper;
+        
+        final long limit;
+        
+        final Queue<Object> queue;
+
+        final AtomicReference<Throwable> error;
+        
+        final AtomicLong requested;
+        
+        final AtomicInteger wip;
+        
+        final NotificationLite<T> nl;
+        
+        volatile boolean done;
+        
+        long produced;
+        
+        Iterator<? extends R> active;
+        
+        public FlattenIterableSubscriber(Subscriber<? super R> actual,
+                Func1<? super T, ? extends Iterable<? extends R>> mapper, int prefetch) {
+            this.actual = actual;
+            this.mapper = mapper;
+            this.error = new AtomicReference<Throwable>();
+            this.wip = new AtomicInteger();
+            this.requested = new AtomicLong();
+            this.nl = NotificationLite.instance();
+            if (prefetch == Integer.MAX_VALUE) {
+                this.limit = Long.MAX_VALUE;
+                this.queue = new SpscLinkedArrayQueue<Object>(RxRingBuffer.SIZE);
+            } else {
+                // limit = prefetch * 75% rounded up
+                this.limit = prefetch - (prefetch >> 2);
+                if (UnsafeAccess.isUnsafeAvailable()) {
+                    this.queue = new SpscArrayQueue<Object>(prefetch);
+                } else {
+                    this.queue = new SpscAtomicArrayQueue<Object>(prefetch);
+                }
+            }
+            request(prefetch);
+        }
+        
+        @Override
+        public void onNext(T t) {
+            if (!queue.offer(nl.next(t))) {
+                unsubscribe();
+                onError(new MissingBackpressureException());
+                return;
+            }
+            drain();
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            if (ExceptionsUtils.addThrowable(error, e)) {
+                done = true;
+                drain();
+            } else {
+                RxJavaPluginUtils.handleException(e);
+            }
+        }
+        
+        @Override
+        public void onCompleted() {
+            done = true;
+            drain();
+        }
+        
+        void requestMore(long n) {
+            if (n > 0) {
+                BackpressureUtils.getAndAddRequest(requested, n);
+                drain();
+            } else if (n < 0) {
+                throw new IllegalStateException("n >= 0 required but it was " + n);
+            }
+        }
+        
+        void drain() {
+            if (wip.getAndIncrement() != 0) {
+                return;
+            }
+            
+            final Subscriber<? super R> actual = this.actual;
+            final Queue<Object> queue = this.queue;
+            
+            int missed = 1;
+            
+            for (;;) {
+                
+                Iterator<? extends R> it = active;
+                
+                if (it == null) {
+                    boolean d = done;
+                    
+                    Object v = queue.poll();
+                    
+                    boolean empty = v == null;
+
+                    if (checkTerminated(d, empty, actual, queue)) {
+                        return;
+                    }
+                    
+                    if (!empty) {
+                    
+                        long p = produced + 1;
+                        if (p == limit) {
+                            produced = 0L;
+                            request(p);
+                        } else {
+                            produced = p;
+                        }
+                        
+                        boolean b;
+                        
+                        try {
+                            Iterable<? extends R> iter = mapper.call(nl.getValue(v));
+                            
+                            it = iter.iterator();
+                            
+                            b = it.hasNext();
+                        } catch (Throwable ex) {
+                            Exceptions.throwIfFatal(ex);
+                            
+                            it = null;
+                            onError(ex);
+                            
+                            continue;
+                        }
+                        
+                        if (!b) {
+                            continue;
+                        }
+                        
+                        active = it;
+                    }
+                }
+                
+                if (it != null) {
+                    long r = requested.get();
+                    long e = 0L;
+                    
+                    while (e != r) {
+                        if (checkTerminated(done, false, actual, queue)) {
+                            return;
+                        }
+                        
+                        R v;
+                        
+                        try {
+                            v = it.next();
+                        } catch (Throwable ex) {
+                            Exceptions.throwIfFatal(ex);
+                            it = null;
+                            active = null;
+                            onError(ex);
+                            break;
+                        }
+                        
+                        actual.onNext(v);
+
+                        if (checkTerminated(done, false, actual, queue)) {
+                            return;
+                        }
+
+                        e++;
+
+                        boolean b;
+                        
+                        try {
+                            b = it.hasNext();
+                        } catch (Throwable ex) {
+                            Exceptions.throwIfFatal(ex);
+                            it = null;
+                            active = null;
+                            onError(ex);
+                            break;
+                        }
+                        
+                        if (!b) {
+                            it = null;
+                            active = null;
+                            break;
+                        }
+                    }
+                    
+                    if (e == r) {
+                        if (checkTerminated(done, queue.isEmpty() && it == null, actual, queue)) {
+                            return;
+                        }
+                    }
+                    
+                    if (e != 0L) {
+                        BackpressureUtils.produced(requested, e);
+                    }
+                    
+                    if (it == null) {
+                        continue;
+                    }
+                }
+                
+                missed = wip.addAndGet(-missed);
+                if (missed == 0) {
+                    break;
+                }
+            }
+        }
+        
+        boolean checkTerminated(boolean d, boolean empty, Subscriber<?> a, Queue<?> q) {
+            if (a.isUnsubscribed()) {
+                q.clear();
+                active = null;
+                return true;
+            }
+            
+            if (d) {
+                Throwable ex = error.get();
+                if (ex != null) {
+                    ex = ExceptionsUtils.terminate(error);
+                    unsubscribe();
+                    q.clear();
+                    active = null;
+                    
+                    a.onError(ex);
+                    return true;
+                } else
+                if (empty) {
+                    
+                    a.onCompleted();
+                    return true;
+                }
+            }
+            
+            return false;
+        }
+    }
+    
+    /**
+     * A custom flattener that works from a scalar value and computes the iterable
+     * during subscription time.
+     *
+     * @param <T> the scalar's value type
+     * @param <R> the result value type
+     */
+    static final class OnSubscribeScalarFlattenIterable<T, R> implements OnSubscribe<R> {
+        final T value;
+        
+        final Func1<? super T, ? extends Iterable<? extends R>> mapper;
+
+        public OnSubscribeScalarFlattenIterable(T value, Func1<? super T, ? extends Iterable<? extends R>> mapper) {
+            this.value = value;
+            this.mapper = mapper;
+        }
+
+        @Override
+        public void call(Subscriber<? super R> t) {
+            Iterator<? extends R> itor;
+            boolean b;
+            try {
+                Iterable<? extends R> it = mapper.call(value);
+                
+                itor = it.iterator();
+                
+                b = itor.hasNext();
+            } catch (Throwable ex) {
+                Exceptions.throwOrReport(ex, t, value);
+                return;
+            }
+            
+            if (!b) {
+                t.onCompleted();
+                return;
+            }
+            
+            t.setProducer(new OnSubscribeFromIterable.IterableProducer<R>(t, itor));
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java b/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
index 9389c4480c..8df3d1c0d8 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
@@ -64,7 +64,7 @@ public void call(final Subscriber<? super T> o) {
         }
     }
 
-    private static final class IterableProducer<T> extends AtomicLong implements Producer {
+    static final class IterableProducer<T> extends AtomicLong implements Producer {
         /** */
         private static final long serialVersionUID = -8730475647105475802L;
         private final Subscriber<? super T> o;
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java b/src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java
new file mode 100644
index 0000000000..7158456a35
--- /dev/null
+++ b/src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java
@@ -0,0 +1,477 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.*;
+
+import rx.Observable;
+import rx.exceptions.TestException;
+import rx.functions.Func1;
+import rx.observers.TestSubscriber;
+import rx.subjects.PublishSubject;
+
+public class OnSubscribeFlattenIterableTest {
+    
+    final Func1<Integer, Iterable<Integer>> mapper = new Func1<Integer, Iterable<Integer>>() {
+        @Override
+        public Iterable<Integer> call(Integer v) {
+            return Arrays.asList(v, v + 1);
+        }
+    };
+    
+    @Test
+    public void normal() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        Observable.range(1, 5).concatMapIterable(mapper)
+        .subscribe(ts);
+        
+        ts.assertValues(1, 2, 2, 3, 3, 4, 4, 5, 5, 6);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void normalBackpressured() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
+        
+        Observable.range(1, 5).concatMapIterable(mapper)
+        .subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+        
+        ts.requestMore(1);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1, 2, 2);
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+        
+        ts.requestMore(7);
+        
+        ts.assertValues(1, 2, 2, 3, 3, 4, 4, 5, 5, 6);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void longRunning() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        int n = 1000 * 1000;
+        
+        Observable.range(1, n).concatMapIterable(mapper)
+        .subscribe(ts);
+
+        ts.assertValueCount(n * 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void asIntermediate() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        int n = 1000 * 1000;
+        
+        Observable.range(1, n).concatMapIterable(mapper).concatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return Observable.just(v);
+            }
+        })
+        .subscribe(ts);
+
+        ts.assertValueCount(n * 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void just() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        Observable.just(1).concatMapIterable(mapper)
+        .subscribe(ts);
+        
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void justHidden() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        Observable.just(1).asObservable().concatMapIterable(mapper)
+        .subscribe(ts);
+        
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void empty() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        Observable.<Integer>empty().concatMapIterable(mapper)
+        .subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void error() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        Observable.<Integer>just(1).concatWith(Observable.<Integer>error(new TestException()))
+        .concatMapIterable(mapper)
+        .subscribe(ts);
+        
+        ts.assertValues(1, 2);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void iteratorHasNextThrowsImmediately() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        final Iterable<Integer> it = new Iterable<Integer>() {
+            @Override
+            public Iterator<Integer> iterator() {
+                return new Iterator<Integer>() {
+                    @Override
+                    public boolean hasNext() {
+                        throw new TestException();
+                    }
+                    
+                    @Override
+                    public Integer next() {
+                        return 1;
+                    }
+                    
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException();
+                    }
+                };
+            }
+        };
+        
+        Observable.range(1, 2)
+        .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
+            @Override
+            public Iterable<Integer> call(Integer v) {
+                return it;
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void iteratorHasNextThrowsImmediatelyJust() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        final Iterable<Integer> it = new Iterable<Integer>() {
+            @Override
+            public Iterator<Integer> iterator() {
+                return new Iterator<Integer>() {
+                    @Override
+                    public boolean hasNext() {
+                        throw new TestException();
+                    }
+                    
+                    @Override
+                    public Integer next() {
+                        return 1;
+                    }
+                    
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException();
+                    }
+                };
+            }
+        };
+        
+        Observable.just(1)
+        .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
+            @Override
+            public Iterable<Integer> call(Integer v) {
+                return it;
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void iteratorHasNextThrowsSecondCall() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        final Iterable<Integer> it = new Iterable<Integer>() {
+            @Override
+            public Iterator<Integer> iterator() {
+                return new Iterator<Integer>() {
+                    int count;
+                    @Override
+                    public boolean hasNext() {
+                        if (++count >= 2) {
+                            throw new TestException();
+                        }
+                        return true;
+                    }
+                    
+                    @Override
+                    public Integer next() {
+                        return 1;
+                    }
+                    
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException();
+                    }
+                };
+            }
+        };
+        
+        Observable.range(1, 2)
+        .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
+            @Override
+            public Iterable<Integer> call(Integer v) {
+                return it;
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void iteratorNextThrows() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        final Iterable<Integer> it = new Iterable<Integer>() {
+            @Override
+            public Iterator<Integer> iterator() {
+                return new Iterator<Integer>() {
+                    @Override
+                    public boolean hasNext() {
+                        return true;
+                    }
+                    
+                    @Override
+                    public Integer next() {
+                        throw new TestException();
+                    }
+                    
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException();
+                    }
+                };
+            }
+        };
+        
+        Observable.range(1, 2)
+        .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
+            @Override
+            public Iterable<Integer> call(Integer v) {
+                return it;
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void iteratorNextThrowsAndUnsubscribes() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        final Iterable<Integer> it = new Iterable<Integer>() {
+            @Override
+            public Iterator<Integer> iterator() {
+                return new Iterator<Integer>() {
+                    @Override
+                    public boolean hasNext() {
+                        return true;
+                    }
+                    
+                    @Override
+                    public Integer next() {
+                        throw new TestException();
+                    }
+                    
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException();
+                    }
+                };
+            }
+        };
+        
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        ps
+        .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
+            @Override
+            public Iterable<Integer> call(Integer v) {
+                return it;
+            }
+        })
+        .unsafeSubscribe(ts);
+        
+        ps.onNext(1);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+        
+        Assert.assertFalse("PublishSubject has Observers?!", ps.hasObservers());
+    }
+
+    @Test
+    public void mixture() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        Observable.range(0, 1000)
+        .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
+            @Override
+            public Iterable<Integer> call(Integer v) {
+                return (v % 2) == 0 ? Collections.singleton(1) : Collections.<Integer>emptySet();
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValueCount(500);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void emptyInnerThenSingleBackpressured() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>(1);
+        
+        Observable.range(1, 2)
+        .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
+            @Override
+            public Iterable<Integer> call(Integer v) {
+                return v == 2 ? Collections.singleton(1) : Collections.<Integer>emptySet();
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void manyEmptyInnerThenSingleBackpressured() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>(1);
+        
+        Observable.range(1, 1000)
+        .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
+            @Override
+            public Iterable<Integer> call(Integer v) {
+                return v == 1000 ? Collections.singleton(1) : Collections.<Integer>emptySet();
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void hasNextIsNotCalledAfterChildUnsubscribedOnNext() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        final AtomicInteger counter = new AtomicInteger();
+        
+        final Iterable<Integer> it = new Iterable<Integer>() {
+            @Override
+            public Iterator<Integer> iterator() {
+                return new Iterator<Integer>() {
+                    @Override
+                    public boolean hasNext() {
+                        counter.getAndIncrement();
+                        return true;
+                    }
+                    
+                    @Override
+                    public Integer next() {
+                        return 1;
+                    }
+                    
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException();
+                    }
+                };
+            }
+        };
+        
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        ps
+        .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
+            @Override
+            public Iterable<Integer> call(Integer v) {
+                return it;
+            }
+        })
+        .take(1)
+        .unsafeSubscribe(ts);
+        
+        ps.onNext(1);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+        Assert.assertFalse("PublishSubject has Observers?!", ps.hasObservers());
+        Assert.assertEquals(1, counter.get());
+    }
+}

From 992d74556b0d2c100f8ac0885e02b4a6126f1c96 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 4 May 2016 20:30:43 +0200
Subject: [PATCH 020/263] Release 1.1.4 CHANGES.md (#3906)

---
 CHANGES.md | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 39da0ad41b..a84e361d4d 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,39 @@
 # RxJava Releases #
 
+### Version 1.1.4 - May 3, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.4%7C))
+
+#### API enhancements
+
+  - [Pull 3856](https://github.com/ReactiveX/RxJava/pull/3856): Provide factories for creating the default scheduler instances.
+  - [Pull 3866](https://github.com/ReactiveX/RxJava/pull/3866): Add `Single.toCompletable()`.
+  - [Pull 3879](https://github.com/ReactiveX/RxJava/pull/3879): Expose scheduler factories which accept thread factories.
+  - [Pull 3820](https://github.com/ReactiveX/RxJava/pull/3820): Making RxPlugins `reset()` public
+  - [Pull 3888](https://github.com/ReactiveX/RxJava/pull/3888): New operator: `onTerminateDetach` - detach upstream/downstream for GC
+
+#### API deprecations
+
+  - [Pull 3871](https://github.com/ReactiveX/RxJava/pull/3871): Deprecate remaining public scheduler types.
+
+#### Performance enhancements
+
+  - [Pull 3761](https://github.com/ReactiveX/RxJava/pull/3761): optimize `merge`/`flatMap` for empty sources.
+  - [Pull 3864](https://github.com/ReactiveX/RxJava/pull/3864): optimize `concatMapIterable`/`flatMapIterable`. 
+
+#### Bugfixes
+
+  - [Pull 3868](https://github.com/ReactiveX/RxJava/pull/3868): Fix an unsubscribe race in `EventLoopWorker`.
+  - [Pull 3867](https://github.com/ReactiveX/RxJava/pull/3867): ensure waiting tasks are cancelled on worker unsubscription.
+  - [Pull 3862](https://github.com/ReactiveX/RxJava/pull/3862): fix `from(Iterable)` error handling of Iterable/Iterator
+  - [Pull 3886](https://github.com/ReactiveX/RxJava/pull/3886): `throwIfFatal()` now throws `OnCompletedFailedException`.
+  - [Pull 3887](https://github.com/ReactiveX/RxJava/pull/3887): Have undeliverable errors on `subscribe()` sent to plugin error handler.
+  - [Pull 3895](https://github.com/ReactiveX/RxJava/pull/3895): `cast()` should unsubscribe on crash eagerly.
+  - [Pull 3896](https://github.com/ReactiveX/RxJava/pull/3896): `OperatorMapPair` should unsubscribe on crash eagerly.
+  - [Pull 3890](https://github.com/ReactiveX/RxJava/pull/3890): `map()` and `filter()` should unsubscribe on crash eagerly.
+  - [Pull 3893](https://github.com/ReactiveX/RxJava/pull/3893): enable backpressure with `from(Future)`
+  - [Pull 3883](https://github.com/ReactiveX/RxJava/pull/3883): fix multiple chained `Single.doAfterTerminate` not calling actions
+  - [Pull 3904](https://github.com/ReactiveX/RxJava/pull/3904): Fix `Completable` swallows `OnErrorNotImplementedException`
+  - [Pull 3905](https://github.com/ReactiveX/RxJava/pull/3905): fix `singleOrDefault()` backpressure if source is empty
+
 ### Version 1.1.3 - April 8, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.3%7C))
 
 #### API enhancements

From cac743040ecae9972f6facacac58cf867acc9b6d Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 5 May 2016 21:29:46 +0200
Subject: [PATCH 021/263] 1.x: fix filter() default-requesting and thus going
 unbounded (#3912)

---
 .../rx/internal/operators/OperatorFilter.java |  1 +
 .../operators/OperatorFilterTest.java         | 20 ++++++++++++++++---
 2 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorFilter.java b/src/main/java/rx/internal/operators/OperatorFilter.java
index 15f1a48ec9..6d489b0e67 100644
--- a/src/main/java/rx/internal/operators/OperatorFilter.java
+++ b/src/main/java/rx/internal/operators/OperatorFilter.java
@@ -53,6 +53,7 @@ static final class FilterSubscriber<T> extends Subscriber<T> {
         public FilterSubscriber(Subscriber<? super T> actual, Func1<? super T, Boolean> predicate) {
             this.actual = actual;
             this.predicate = predicate;
+            request(0);
         }
         
         @Override
diff --git a/src/test/java/rx/internal/operators/OperatorFilterTest.java b/src/test/java/rx/internal/operators/OperatorFilterTest.java
index 543dc06cf7..5a8ebeb9f6 100644
--- a/src/test/java/rx/internal/operators/OperatorFilterTest.java
+++ b/src/test/java/rx/internal/operators/OperatorFilterTest.java
@@ -26,7 +26,7 @@
 import rx.*;
 import rx.exceptions.*;
 import rx.functions.*;
-import rx.internal.util.RxRingBuffer;
+import rx.internal.util.*;
 import rx.observers.TestSubscriber;
 import rx.subjects.PublishSubject;
 
@@ -69,7 +69,7 @@ public Boolean call(String t1) {
         });
 
         final CountDownLatch latch = new CountDownLatch(1);
-        TestSubscriber<String> ts = new TestSubscriber<String>() {
+        TestSubscriber<String> ts = new TestSubscriber<String>(0L) {
 
             @Override
             public void onCompleted() {
@@ -116,7 +116,7 @@ public Boolean call(Integer t1) {
         });
 
         final CountDownLatch latch = new CountDownLatch(1);
-        final TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
+        final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L) {
             
             @Override
             public void onCompleted() {
@@ -194,4 +194,18 @@ public Boolean call(Integer v) {
         ts.assertError(TestException.class);
     }
 
+    @Test
+    public void doesntRequestOnItsOwn() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0L);
+        
+        Observable.range(1, 10).filter(UtilityFunctions.alwaysTrue()).unsafeSubscribe(ts);
+        
+        ts.assertNoValues();
+        
+        ts.requestMore(10);
+        
+        ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }

From 4874bbecbae5c6a669ce005ea03f19ef71c3d33b Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 5 May 2016 21:31:15 +0200
Subject: [PATCH 022/263] 1.x: Single.retryWhen javadoc clarifications (#3909)

---
 src/main/java/rx/Single.java | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index bba3555a55..7ba3325434 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -2603,10 +2603,28 @@ public final Single<T> retry(Func2<Integer, Throwable, Boolean> predicate) {
      * Returns a Single that emits the same values as the source Single with the exception of an
      * {@code onError}. An {@code onError} notification from the source will result in the emission of a
      * {@link Throwable} item to the Observable provided as an argument to the {@code notificationHandler}
-     * function. If that Observable calls {@code onComplete} or {@code onError} then {@code retry} will call
-     * {@code onCompleted} or {@code onError} on the child subscription. Otherwise, this Observable will
-     * resubscribe to the source Single.
-     *
+     * function. 
+     * <p>Emissions from the handler {@code Observable} is treated as follows:
+     * <ul>
+     * <li>If the handler {@code Observable} emits an {@code onCompleted} the {@code retryWhen} will call {@code onError}
+     * with {@code NoSuchElementException} on the child subscription.</li> 
+     * <li>If the handler {@code Observable} emits an {@code onError} the {@code retryWhen} will call
+     * {@code onError} with the same Throwable instance on the child subscription. 
+     * <li>Otherwise, the operator will resubscribe to the source Single.</li>
+     * </ul>
+     * <p>The {@code notificationHandler} function is called for each subscriber individually. This allows per-Subscriber
+     * state to be added to the error notification sequence.</p>
+     * <pre><code>
+     * single.retryWhen(error -&gt; {
+     *     AtomicInteger counter = new AtomicInteger();
+     *     return error.takeWhile(e -&gt; counter.incrementAndGet() &lt; 3).map(e -&gt; "retry");
+     * }).subscribe(...);
+     * </code></pre>
+     * <p>
+     * Note that you must compose over the input {@code Observable} provided in the function call because {@retryWhen} expects
+     * an emission of the exception to be matched by an event from the handler Observable.
+     * <p>
+     * 
      * <img width="640" height="430" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/retryWhen.f.png" alt="">
      *
      * <dl>

From 5293fd07514b39c327d54b556be2ef9c2cba6bfa Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 5 May 2016 21:31:31 +0200
Subject: [PATCH 023/263] 1.x: DoOnUnsubscribe javadoc clarifications (#3907)

---
 src/main/java/rx/Observable.java | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 39c09ad477..dd575905e4 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -4774,13 +4774,21 @@ public final Observable<T> doOnTerminate(final Action0 onTerminate) {
     }
     
     /**
-     * Modifies the source {@code Observable} so that it invokes the given action when it is unsubscribed from
-     * its subscribers. Each un-subscription will result in an invocation of the given action except when the
-     * source {@code Observable} is reference counted, in which case the source {@code Observable} will invoke
-     * the given action for the very last un-subscription.
+     * Calls the unsubscribe {@code Action0} if the downstream unsubscribes the sequence.
+     * <p>
+     * The action is shared between subscriptions and thus may be called concurrently from multiple
+     * threads; the action must be thread safe.
+     * <p>
+     * If the action throws a runtime exception, that exception is rethrown by the {@code unsubscribe()} call,
+     * sometimes as a {@code CompositeException} if there were multiple exceptions along the way.
+     * <p>
+     * Note that terminal events trigger the action unless the {@code Observable} is subscribed to via {@code unsafeSubscribe()}.
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/doOnUnsubscribe.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>{@code doOnUnsubscribe} does not interact with backpressure requests or value delivery; backpressure
+     *  behavior is preserved between its upstream and its downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnUnsubscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>

From 1512c1005e8fc819070453abff5678b34bf5fa6d Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 5 May 2016 22:04:52 +0200
Subject: [PATCH 024/263] Release 1.1.5 CHANGES.md update (#3913)

---
 CHANGES.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index a84e361d4d..61ed87a90c 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,11 @@
 # RxJava Releases #
 
+### Version 1.1.5 - May 5, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.5%7C))
+
+#### Bugfixes
+
+  - [Pull 3912](https://github.com/ReactiveX/RxJava/pull/3912): fix filter() default-requesting and thus going unbounded
+
 ### Version 1.1.4 - May 3, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.4%7C))
 
 #### API enhancements

From 2a8d6c75205b13cd9bef2b7f7d47723e1c86454e Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 10 May 2016 21:51:02 +0200
Subject: [PATCH 025/263] 1.x: fix RxRingBuffer-pool depending on the
 computation scheduler (#3924)

---
 .../java/rx/internal/util/ObjectPool.java     | 72 +++++++++++--------
 1 file changed, 41 insertions(+), 31 deletions(-)

diff --git a/src/main/java/rx/internal/util/ObjectPool.java b/src/main/java/rx/internal/util/ObjectPool.java
index 0aa005208e..35da79335a 100644
--- a/src/main/java/rx/internal/util/ObjectPool.java
+++ b/src/main/java/rx/internal/util/ObjectPool.java
@@ -21,11 +21,8 @@
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicReference;
 
-import rx.Scheduler.Worker;
-import rx.functions.Action0;
-import rx.internal.schedulers.SchedulerLifecycle;
+import rx.internal.schedulers.*;
 import rx.internal.util.unsafe.*;
-import rx.schedulers.Schedulers;
 
 public abstract class ObjectPool<T> implements SchedulerLifecycle {
     Queue<T> pool;
@@ -33,7 +30,7 @@ public abstract class ObjectPool<T> implements SchedulerLifecycle {
     final int maxSize;
     private final long validationInterval;
 
-    private final AtomicReference<Worker> schedulerWorker;
+    private final AtomicReference<Future<?>> periodicTask;
 
     public ObjectPool() {
         this(0, 0, 67);
@@ -55,7 +52,7 @@ private ObjectPool(final int min, final int max, final long validationInterval)
         this.minSize = min;
         this.maxSize = max;
         this.validationInterval = validationInterval;
-        this.schedulerWorker = new AtomicReference<Worker>();
+        this.periodicTask = new AtomicReference<Future<?>>();
         // initialize pool
         initialize(min);
 
@@ -96,38 +93,51 @@ public void returnObject(T object) {
      */
     @Override
     public void shutdown() {
-        Worker w = schedulerWorker.getAndSet(null);
-        if (w != null) {
-            w.unsubscribe();
+        Future<?> f = periodicTask.getAndSet(null);
+        if (f != null) {
+            f.cancel(false);
         }
     }
 
     @Override
     public void start() {
-        Worker w = Schedulers.computation().createWorker();
-        if (schedulerWorker.compareAndSet(null, w)) {
-            w.schedulePeriodically(new Action0() {
-    
-                @Override
-                public void call() {
-                    int size = pool.size();
-                    if (size < minSize) {
-                        int sizeToBeAdded = maxSize - size;
-                        for (int i = 0; i < sizeToBeAdded; i++) {
-                            pool.add(createObject());
-                        }
-                    } else if (size > maxSize) {
-                        int sizeToBeRemoved = size - maxSize;
-                        for (int i = 0; i < sizeToBeRemoved; i++) {
-                            //                        pool.pollLast();
-                            pool.poll();
+        for (;;) {
+            if (periodicTask.get() != null) {
+                return;
+            }
+            ScheduledExecutorService w = GenericScheduledExecutorService.getInstance();
+            
+            Future<?> f;
+            try {
+                f = w.scheduleAtFixedRate(new Runnable() {
+        
+                    @Override
+                    public void run() {
+                        int size = pool.size();
+                        if (size < minSize) {
+                            int sizeToBeAdded = maxSize - size;
+                            for (int i = 0; i < sizeToBeAdded; i++) {
+                                pool.add(createObject());
+                            }
+                        } else if (size > maxSize) {
+                            int sizeToBeRemoved = size - maxSize;
+                            for (int i = 0; i < sizeToBeRemoved; i++) {
+                                //                        pool.pollLast();
+                                pool.poll();
+                            }
                         }
                     }
-                }
-    
-            }, validationInterval, validationInterval, TimeUnit.SECONDS);
-        } else {
-            w.unsubscribe();
+        
+                }, validationInterval, validationInterval, TimeUnit.SECONDS);
+            } catch (RejectedExecutionException ex) {
+                RxJavaPluginUtils.handleException(ex);
+                break;
+            }
+            if (!periodicTask.compareAndSet(null, f)) {
+                f.cancel(false);
+            } else {
+                break;
+            }
         }
     }
     

From ac96d21f9891e5f5f91d87a803994146e2a5978a Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 10 May 2016 21:51:29 +0200
Subject: [PATCH 026/263] 1.x: Subscriber.NOT_SET Long -> long, saves an
 unboxing per instance (#3919)

---
 src/main/java/rx/Subscriber.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/rx/Subscriber.java b/src/main/java/rx/Subscriber.java
index cfbfcc2496..3b8913a9f0 100644
--- a/src/main/java/rx/Subscriber.java
+++ b/src/main/java/rx/Subscriber.java
@@ -33,7 +33,7 @@
 public abstract class Subscriber<T> implements Observer<T>, Subscription {
     
     // represents requested not set yet
-    private static final Long NOT_SET = Long.MIN_VALUE;
+    private static final long NOT_SET = Long.MIN_VALUE;
 
     private final SubscriptionList subscriptions;
     private final Subscriber<?> subscriber;

From d43c05cb0f011e7647cdf176fcd2620bb4a95e8e Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 10 May 2016 23:23:57 +0200
Subject: [PATCH 027/263] 1.x: fix using() resource cleanup when factory throws
 or being non-eager (#3922)

---
 .../internal/operators/OnSubscribeUsing.java  | 55 +++++++----
 .../operators/OnSubscribeUsingTest.java       | 98 +++++++++++++++----
 2 files changed, 116 insertions(+), 37 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OnSubscribeUsing.java b/src/main/java/rx/internal/operators/OnSubscribeUsing.java
index 4dd483b4cc..352c699056 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeUsing.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeUsing.java
@@ -15,7 +15,6 @@
  */
 package rx.internal.operators;
 
-import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.*;
@@ -26,6 +25,9 @@
 
 /**
  * Constructs an observable sequence that depends on a resource object.
+ * 
+ * @param <T> the output value type
+ * @param <Resource> the resource type
  */
 public final class OnSubscribeUsing<T, Resource> implements OnSubscribe<T> {
 
@@ -56,26 +58,46 @@ public void call(final Subscriber<? super T> subscriber) {
             // dispose on unsubscription
             subscriber.add(disposeOnceOnly);
             // create the observable
-            final Observable<? extends T> source = observableFactory
-            // create the observable
-                    .call(resource);
+            final Observable<? extends T> source;
+
+            try {
+                source = observableFactory
+                // create the observable
+                        .call(resource);
+            } catch (Throwable e) {
+                Throwable disposeError = dispose(disposeOnceOnly);
+                Exceptions.throwIfFatal(e);
+                Exceptions.throwIfFatal(disposeError);
+                if (disposeError != null) {
+                    subscriber.onError(new CompositeException(e, disposeError));
+                } else {
+                    // propagate error
+                    subscriber.onError(e);
+                }
+                return;
+            }
+
             final Observable<? extends T> observable;
             // supplement with on termination disposal if requested
-            if (disposeEagerly)
+            if (disposeEagerly) {
                 observable = source
                 // dispose on completion or error
                         .doOnTerminate(disposeOnceOnly);
-            else
-                observable = source;
+            } else {
+                observable = source
+                // dispose after the terminal signals were sent out
+                        .doAfterTerminate(disposeOnceOnly);
+            }
+            
             try {
                 // start
                 observable.unsafeSubscribe(Subscribers.wrap(subscriber));
             } catch (Throwable e) {
-                Throwable disposeError = disposeEagerlyIfRequested(disposeOnceOnly);
+                Throwable disposeError = dispose(disposeOnceOnly);
                 Exceptions.throwIfFatal(e);
                 Exceptions.throwIfFatal(disposeError);
                 if (disposeError != null)
-                    subscriber.onError(new CompositeException(Arrays.asList(e, disposeError)));
+                    subscriber.onError(new CompositeException(e, disposeError));
                 else
                     // propagate error
                     subscriber.onError(e);
@@ -86,16 +108,13 @@ public void call(final Subscriber<? super T> subscriber) {
         }
     }
 
-    private Throwable disposeEagerlyIfRequested(final Action0 disposeOnceOnly) {
-        if (disposeEagerly)
-            try {
-                disposeOnceOnly.call();
-                return null;
-            } catch (Throwable e) {
-                return e;
-            }
-        else
+    private Throwable dispose(final Action0 disposeOnceOnly) {
+        try {
+            disposeOnceOnly.call();
             return null;
+        } catch (Throwable e) {
+            return e;
+        }
     }
 
     private static final class DisposeAction<Resource> extends AtomicBoolean implements Action0,
diff --git a/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java b/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
index a68605dd8c..47b2338bbc 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
@@ -15,31 +15,22 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import org.junit.Test;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.*;
 import org.mockito.InOrder;
 
+import rx.*;
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
 import rx.exceptions.TestException;
-import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.functions.Func0;
-import rx.functions.Func1;
+import rx.functions.*;
+import rx.observers.TestSubscriber;
 import rx.subscriptions.Subscriptions;
 
 public class OnSubscribeUsingTest {
@@ -432,4 +423,73 @@ public void call() {
         };
     }
     
+    @Test
+    public void factoryThrows() {
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        final AtomicInteger count = new AtomicInteger();
+        
+        Observable.<Integer, Integer>using(
+                new Func0<Integer>() {
+                    @Override
+                    public Integer call() {
+                        return 1;
+                    }
+                }, 
+                new Func1<Integer, Observable<Integer>>() {
+                    @Override
+                    public Observable<Integer> call(Integer v) { 
+                        throw new TestException("forced failure"); 
+                    }
+                }, 
+                new Action1<Integer>() {
+                    @Override
+                    public void call(Integer c) {
+                        count.incrementAndGet();
+                    }
+                }
+        )
+        .unsafeSubscribe(ts);
+        
+        ts.assertError(TestException.class);
+        
+        Assert.assertEquals(1, count.get());
+    }
+    
+    @Test
+    public void nonEagerTermination() {
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        final AtomicInteger count = new AtomicInteger();
+        
+        Observable.<Integer, Integer>using(
+                new Func0<Integer>() {
+                    @Override
+                    public Integer call() {
+                        return 1;
+                    }
+                }, 
+                new Func1<Integer, Observable<Integer>>() {
+                    @Override
+                    public Observable<Integer> call(Integer v) { 
+                        return Observable.just(v);
+                    }
+                }, 
+                new Action1<Integer>() {
+                    @Override
+                    public void call(Integer c) {
+                        count.incrementAndGet();
+                    }
+                }, false
+        )
+        .unsafeSubscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+        Assert.assertEquals(1, count.get());
+    }
 }

From 4a6441ce8d49ed9084ca968a7163dbf3b759827b Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 17 May 2016 21:57:36 +0200
Subject: [PATCH 028/263] 1.x: fix Single.flatMap not composing subscription
 through (#3941)

Closes  #3940.
---
 src/main/java/rx/Single.java     |  6 +++--
 src/test/java/rx/SingleTest.java | 40 ++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 7ba3325434..c7ce03b27a 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -671,7 +671,7 @@ public static <T> Single<T> merge(final Single<? extends Single<? extends T>> so
 
             @Override
             public void call(final SingleSubscriber<? super T> child) {
-                source.subscribe(new SingleSubscriber<Single<? extends T>>() {
+                SingleSubscriber<Single<? extends T>> parent = new SingleSubscriber<Single<? extends T>>() {
 
                     @Override
                     public void onSuccess(Single<? extends T> innerSingle) {
@@ -683,7 +683,9 @@ public void onError(Throwable error) {
                         child.onError(error);
                     }
 
-                });
+                };
+                child.add(parent);
+                source.subscribe(parent);
             }
         });
     }
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index 3760330eb4..2520667ccf 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -1914,4 +1914,44 @@ public void subscribeWithNullObserver() {
             assertEquals("observer is null", ex.getMessage());
         }
     }
+
+    @Test
+    public void unsubscribeComposesThrough() {
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        Subscription s = ps.toSingle()
+        .flatMap(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(1);
+            }
+        })
+        .subscribe();
+        
+        s.unsubscribe();
+        
+        assertFalse("Observers present?!", ps.hasObservers());
+    }
+
+    @Test(timeout = 1000)
+    public void unsubscribeComposesThroughAsync() {
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        Subscription s = ps.toSingle()
+        .subscribeOn(Schedulers.io())
+        .flatMap(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(1);
+            }
+        })
+        .subscribe();
+        
+        while (!ps.hasObservers() && !Thread.currentThread().isInterrupted()) ;
+        
+        s.unsubscribe();
+        
+        assertFalse("Observers present?!", ps.hasObservers());
+    }
+
 }

From edc4d502cc2a6db8c7968e7048fed4310d7a34ba Mon Sep 17 00:00:00 2001
From: loveyoupeng <loveyoupeng@gmail.com>
Date: Tue, 17 May 2016 17:06:01 -0500
Subject: [PATCH 029/263] fix exception message (#3944)

---
 src/main/java/rx/Observable.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index dd575905e4..ecec3ab339 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -8523,7 +8523,7 @@ public final Subscription subscribe(Subscriber<? super T> subscriber) {
     static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
      // validate and proceed
         if (subscriber == null) {
-            throw new IllegalArgumentException("observer can not be null");
+            throw new IllegalArgumentException("subscriber can not be null");
         }
         if (observable.onSubscribe == null) {
             throw new IllegalStateException("onSubscribe function can not be null.");

From 91888b362b5024cb1ff46c1f4d8740bf0e7e797b Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 18 May 2016 22:16:12 +0200
Subject: [PATCH 030/263] 1.x: javac- and javadoc-related cleanup in
 components, part 1 (#3949)

---
 src/main/java/rx/BackpressureOverflow.java    |   6 +-
 src/main/java/rx/Observable.java              |   5 +
 src/main/java/rx/Single.java                  |   4 +
 .../rx/exceptions/CompositeException.java     |   6 +-
 .../OnCompletedFailedException.java           |   4 +-
 src/main/java/rx/functions/Action1.java       |   1 +
 src/main/java/rx/functions/Action2.java       |   2 +
 src/main/java/rx/functions/Action3.java       |   3 +
 src/main/java/rx/functions/Action4.java       |   4 +
 src/main/java/rx/functions/Action5.java       |   5 +
 src/main/java/rx/functions/Action6.java       |   6 ++
 src/main/java/rx/functions/Action7.java       |   7 ++
 src/main/java/rx/functions/Action8.java       |   8 ++
 src/main/java/rx/functions/Action9.java       |   9 ++
 src/main/java/rx/functions/Actions.java       | 102 ++++++++++++++++++
 src/main/java/rx/functions/Func0.java         |   1 +
 src/main/java/rx/functions/Func1.java         |   2 +
 src/main/java/rx/functions/Func2.java         |   3 +
 src/main/java/rx/functions/Func3.java         |   4 +
 src/main/java/rx/functions/Func4.java         |   5 +
 src/main/java/rx/functions/Func5.java         |   6 ++
 src/main/java/rx/functions/Func6.java         |   7 ++
 src/main/java/rx/functions/Func7.java         |   8 ++
 src/main/java/rx/functions/Func8.java         |   9 ++
 src/main/java/rx/functions/Func9.java         |  10 ++
 src/main/java/rx/functions/FuncN.java         |   1 +
 src/main/java/rx/functions/Functions.java     |  61 +++++++++++
 .../operators/BlockingOperatorLatest.java     |   1 -
 .../operators/BufferUntilSubscriber.java      |   2 +
 .../SingleOperatorOnErrorResumeNext.java      |   1 -
 .../schedulers/EventLoopsScheduler.java       |   1 +
 .../schedulers/ExecutorScheduler.java         |   4 -
 .../internal/schedulers/NewThreadWorker.java  |  11 +-
 .../util/BackpressureDrainManager.java        |   2 +
 .../rx/internal/util/IndexedRingBuffer.java   |   7 +-
 .../util/InternalObservableUtils.java         |  16 ++-
 .../rx/internal/util/LinkedArrayList.java     |  10 +-
 .../rx/internal/util/PlatformDependent.java   |   1 +
 .../rx/internal/util/RxThreadFactory.java     |   3 +
 .../rx/internal/util/UtilityFunctions.java    |  14 +++
 .../util/atomic/BaseLinkedAtomicQueue.java    |   2 -
 .../util/atomic/MpscLinkedAtomicQueue.java    |   2 -
 .../atomic/SpscExactAtomicArrayQueue.java     |   1 +
 .../util/atomic/SpscLinkedAtomicQueue.java    |   1 -
 .../atomic/SpscUnboundedAtomicArrayQueue.java |   1 +
 .../java/rx/observables/AsyncOnSubscribe.java |  15 ++-
 .../rx/observables/BlockingObservable.java    |  10 ++
 .../rx/observables/GroupedObservable.java     |   5 +-
 .../java/rx/observables/SyncOnSubscribe.java  |  27 +++--
 src/main/java/rx/observers/Observers.java     |   5 +-
 src/main/java/rx/observers/Subscribers.java   |  12 ++-
 src/main/java/rx/observers/TestObserver.java  |   1 +
 .../RxJavaObservableExecutionHook.java        |   7 ++
 .../java/rx/plugins/RxJavaSchedulersHook.java |  12 +++
 .../rx/plugins/RxJavaSingleExecutionHook.java |  21 ++--
 .../rx/schedulers/ImmediateScheduler.java     |   2 +-
 .../rx/schedulers/NewThreadScheduler.java     |   2 +-
 src/main/java/rx/schedulers/TimeInterval.java |   1 +
 src/main/java/rx/schedulers/Timestamped.java  |   1 +
 .../rx/schedulers/TrampolineScheduler.java    |   2 +-
 src/main/java/rx/singles/BlockingSingle.java  |   4 +
 .../java/rx/subjects/SerializedSubject.java   |   3 +
 src/main/java/rx/subjects/Subject.java        |   2 +
 .../subjects/SubjectSubscriptionManager.java  |   2 +
 .../subscriptions/RefCountSubscription.java   |   3 +
 src/test/java/rx/CovarianceTest.java          |   1 +
 src/test/java/rx/ErrorHandlingTests.java      |   2 +
 src/test/java/rx/MergeTests.java              |   5 +-
 src/test/java/rx/ObservableTests.java         |   1 +
 src/test/java/rx/SingleTest.java              |  28 ++++-
 .../rx/exceptions/CompositeExceptionTest.java |   6 ++
 .../java/rx/exceptions/ExceptionsTest.java    |   2 +
 .../java/rx/exceptions/OnNextValueTest.java   |   1 -
 .../operators/OperatorConcatTest.java         |   1 +
 .../operators/OperatorGroupByTest.java        |   2 +
 .../operators/OperatorMaterializeTest.java    |   2 +-
 .../internal/operators/OperatorMergeTest.java |   3 +
 .../OperatorOnBackpressureDropTest.java       |   1 -
 .../internal/operators/OperatorRetryTest.java |   7 +-
 .../OperatorTakeUntilPredicateTest.java       |   2 +-
 .../schedulers/NewThreadWorkerTest.java       |  14 +--
 .../internal/util/RxRingBufferSpmcTest.java   |   1 +
 .../internal/util/RxRingBufferSpscTest.java   |   1 +
 .../util/RxRingBufferWithoutUnsafeTest.java   |   1 +
 .../util/ScalarSynchronousSingleTest.java     |   2 +-
 .../java/rx/observers/SafeSubscriberTest.java |   8 +-
 .../AbstractSchedulerConcurrencyTests.java    |   1 +
 .../java/rx/schedulers/SchedulerTests.java    |   5 +
 .../java/rx/singles/BlockingSingleTest.java   |   3 +
 src/test/java/rx/test/OperatorTester.java     |   4 +-
 src/test/java/rx/util/AssertObservable.java   |  11 +-
 91 files changed, 532 insertions(+), 89 deletions(-)

diff --git a/src/main/java/rx/BackpressureOverflow.java b/src/main/java/rx/BackpressureOverflow.java
index 325cc7d0c9..761a2c4a80 100644
--- a/src/main/java/rx/BackpressureOverflow.java
+++ b/src/main/java/rx/BackpressureOverflow.java
@@ -37,11 +37,11 @@ public interface Strategy {
     }
 
     public static final BackpressureOverflow.Strategy ON_OVERFLOW_DEFAULT = Error.INSTANCE;
-    @SuppressWarnings("unused")
+
     public static final BackpressureOverflow.Strategy ON_OVERFLOW_ERROR = Error.INSTANCE;
-    @SuppressWarnings("unused")
+
     public static final BackpressureOverflow.Strategy ON_OVERFLOW_DROP_OLDEST = DropOldest.INSTANCE;
-    @SuppressWarnings("unused")
+
     public static final BackpressureOverflow.Strategy ON_OVERFLOW_DROP_LATEST = DropLatest.INSTANCE;
 
     /**
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index ecec3ab339..7e0e89a77a 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -116,6 +116,7 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
      * 
      * @param <T>
      *            the type of the items that this Observable emits
+     * @param <S> the state type
      * @param syncOnSubscribe
      *            an implementation of {@link SyncOnSubscribe}. There are many static creation methods 
      *            on the class for convenience.  
@@ -151,6 +152,7 @@ public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe)
      * 
      * @param <T>
      *            the type of the items that this Observable emits
+     * @param <S> the state type
      * @param asyncOnSubscribe
      *            an implementation of {@link AsyncOnSubscribe}. There are many static creation methods 
      *            on the class for convenience. 
@@ -167,6 +169,7 @@ public static <S, T> Observable<T> create(AsyncOnSubscribe<S, T> asyncOnSubscrib
 
     /**
      * Invoked when Observable.subscribe is called.
+     * @param <T> the output value type
      */
     public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
         // cover for generics insanity
@@ -174,6 +177,8 @@ public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
 
     /**
      * Operator function for lifting into an Observable.
+     * @param <T> the upstream's value type (input)
+     * @param <R> the downstream's value type (output)
      */
     public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<? super T>> {
         // cover for generics insanity
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index c7ce03b27a..5bbe3f2e22 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -135,6 +135,7 @@ public static <T> Single<T> create(OnSubscribe<T> f) {
 
     /**
      * Invoked when Single.execute is called.
+     * @param <T> the output value type
      */
     public interface OnSubscribe<T> extends Action1<SingleSubscriber<? super T>> {
         // cover for generics insanity
@@ -157,6 +158,7 @@ public interface OnSubscribe<T> extends Action1<SingleSubscriber<? super T>> {
      * <dd>{@code lift} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the downstream's value type (output)
      * @param lift
      *            the Operator that implements the Single-operating function to be applied to the source Single
      * @return a Single that is the result of applying the lifted Operator to the source Single
@@ -657,12 +659,14 @@ public static <T> Single<T> just(final T value) {
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the value type of the sources and the output
      * @param source
      *            a {@code Single} that emits a {@code Single}
      * @return a {@code Single} that emits the item that is the result of flattening the {@code Single} emitted
      *         by {@code source}
      * @see <a href="http://reactivex.io/documentation/operators/merge.html">ReactiveX operators documentation: Merge</a>
      */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
     public static <T> Single<T> merge(final Single<? extends Single<? extends T>> source) {
         if (source instanceof ScalarSynchronousSingle) {
             return ((ScalarSynchronousSingle<T>) source).scalarFlatMap((Func1) UtilityFunctions.identity());
diff --git a/src/main/java/rx/exceptions/CompositeException.java b/src/main/java/rx/exceptions/CompositeException.java
index be6169060c..b093c41437 100644
--- a/src/main/java/rx/exceptions/CompositeException.java
+++ b/src/main/java/rx/exceptions/CompositeException.java
@@ -41,7 +41,11 @@ public final class CompositeException extends RuntimeException {
     private final List<Throwable> exceptions;
     private final String message;
 
-    /** @deprecated please use {@link #CompositeException(Collection)} */
+    /** 
+     * Constructs a CompositeException with the given prefix and error collection.
+     * @param messagePrefix the prefix to use (actually unused)
+     * @param errors the collection of errors
+     * @deprecated please use {@link #CompositeException(Collection)} */
     @Deprecated
     public CompositeException(String messagePrefix, Collection<? extends Throwable> errors) {
         Set<Throwable> deDupedExceptions = new LinkedHashSet<Throwable>();
diff --git a/src/main/java/rx/exceptions/OnCompletedFailedException.java b/src/main/java/rx/exceptions/OnCompletedFailedException.java
index 2586c9b692..e6ae90c5ff 100644
--- a/src/main/java/rx/exceptions/OnCompletedFailedException.java
+++ b/src/main/java/rx/exceptions/OnCompletedFailedException.java
@@ -27,7 +27,7 @@ public final class OnCompletedFailedException extends RuntimeException {
     /**
      * Wraps the {@code Throwable} before it is to be re-thrown as an {@code OnCompletedFailedException}.
      *
-     * @param e
+     * @param throwable
      *          the {@code Throwable} to re-throw; if null, a NullPointerException is constructed
      */
     public OnCompletedFailedException(Throwable throwable) {
@@ -40,7 +40,7 @@ public OnCompletedFailedException(Throwable throwable) {
      *
      * @param message
      *          the message to assign to the {@code Throwable} to re-throw
-     * @param e
+     * @param throwable
      *          the {@code Throwable} to re-throw; if null, a NullPointerException is constructed
      */
     public OnCompletedFailedException(String message, Throwable throwable) {
diff --git a/src/main/java/rx/functions/Action1.java b/src/main/java/rx/functions/Action1.java
index e3f906b6e6..ce9da099e7 100644
--- a/src/main/java/rx/functions/Action1.java
+++ b/src/main/java/rx/functions/Action1.java
@@ -17,6 +17,7 @@
 
 /**
  * A one-argument action.
+ * @param <T> the first argument type
  */
 public interface Action1<T> extends Action {
     void call(T t);
diff --git a/src/main/java/rx/functions/Action2.java b/src/main/java/rx/functions/Action2.java
index b22cd77911..c46b957f18 100644
--- a/src/main/java/rx/functions/Action2.java
+++ b/src/main/java/rx/functions/Action2.java
@@ -17,6 +17,8 @@
 
 /**
  * A two-argument action.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
  */
 public interface Action2<T1, T2> extends Action {
     void call(T1 t1, T2 t2);
diff --git a/src/main/java/rx/functions/Action3.java b/src/main/java/rx/functions/Action3.java
index 56a9dd64a9..e961358703 100644
--- a/src/main/java/rx/functions/Action3.java
+++ b/src/main/java/rx/functions/Action3.java
@@ -17,6 +17,9 @@
 
 /**
  * A three-argument action.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
  */
 public interface Action3<T1, T2, T3> extends Action {
     void call(T1 t1, T2 t2, T3 t3);
diff --git a/src/main/java/rx/functions/Action4.java b/src/main/java/rx/functions/Action4.java
index c0e2999bd4..565fc51cbb 100644
--- a/src/main/java/rx/functions/Action4.java
+++ b/src/main/java/rx/functions/Action4.java
@@ -18,6 +18,10 @@
 
 /**
  * A four-argument action.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
  */
 public interface Action4<T1, T2, T3, T4> extends Action {
     void call(T1 t1, T2 t2, T3 t3, T4 t4);
diff --git a/src/main/java/rx/functions/Action5.java b/src/main/java/rx/functions/Action5.java
index 78d5237e6b..dcc3971c4e 100644
--- a/src/main/java/rx/functions/Action5.java
+++ b/src/main/java/rx/functions/Action5.java
@@ -18,6 +18,11 @@
 
 /**
  * A five-argument action.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
+ * @param <T5> the fifth argument type
  */
 public interface Action5<T1, T2, T3, T4, T5> extends Action {
     void call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5);
diff --git a/src/main/java/rx/functions/Action6.java b/src/main/java/rx/functions/Action6.java
index 3908969444..0d298c4ab1 100644
--- a/src/main/java/rx/functions/Action6.java
+++ b/src/main/java/rx/functions/Action6.java
@@ -18,6 +18,12 @@
 
 /**
  * A six-argument action.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
+ * @param <T5> the fifth argument type
+ * @param <T6> the sixth argument type
  */
 public interface Action6<T1, T2, T3, T4, T5, T6> extends Action {
     void call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6);
diff --git a/src/main/java/rx/functions/Action7.java b/src/main/java/rx/functions/Action7.java
index 60bec4b877..513844ae19 100644
--- a/src/main/java/rx/functions/Action7.java
+++ b/src/main/java/rx/functions/Action7.java
@@ -17,6 +17,13 @@
 
 /**
  * A seven-argument action.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
+ * @param <T5> the fifth argument type
+ * @param <T6> the sixth argument type
+ * @param <T7> the seventh argument type
  */
 public interface Action7<T1, T2, T3, T4, T5, T6, T7> extends Action {
     void call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7);
diff --git a/src/main/java/rx/functions/Action8.java b/src/main/java/rx/functions/Action8.java
index 43da8ed309..86a09a3c97 100644
--- a/src/main/java/rx/functions/Action8.java
+++ b/src/main/java/rx/functions/Action8.java
@@ -17,6 +17,14 @@
 
 /**
  * An eight-argument action.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
+ * @param <T5> the fifth argument type
+ * @param <T6> the sixth argument type
+ * @param <T7> the seventh argument type
+ * @param <T8> the eigth argument type
  */
 public interface Action8<T1, T2, T3, T4, T5, T6, T7, T8> extends Action {
     void call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8);
diff --git a/src/main/java/rx/functions/Action9.java b/src/main/java/rx/functions/Action9.java
index 012fe3040c..acb0c83c26 100644
--- a/src/main/java/rx/functions/Action9.java
+++ b/src/main/java/rx/functions/Action9.java
@@ -17,6 +17,15 @@
 
 /**
  * A nine-argument action.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
+ * @param <T5> the fifth argument type
+ * @param <T6> the sixth argument type
+ * @param <T7> the seventh argument type
+ * @param <T8> the eigth argument type
+ * @param <T9> the ninth argument type
  */
 public interface Action9<T1, T2, T3, T4, T5, T6, T7, T8, T9> extends Action {
     void call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9);
diff --git a/src/main/java/rx/functions/Actions.java b/src/main/java/rx/functions/Actions.java
index bbf9d0b151..877c1adbda 100644
--- a/src/main/java/rx/functions/Actions.java
+++ b/src/main/java/rx/functions/Actions.java
@@ -105,6 +105,7 @@ public static Func0<Void> toFunc(final Action0 action) {
     /**
      * Converts an {@link Action1} to a function that calls the action and returns {@code null}.
      * 
+     * @param <T1> the first argument type
      * @param action
      *            the {@link Action1} to convert
      * @return a {@link Func1} that calls {@code action} and returns {@code null}
@@ -116,6 +117,8 @@ public static <T1> Func1<T1, Void> toFunc(final Action1<T1> action) {
     /**
      * Converts an {@link Action2} to a function that calls the action and returns {@code null}.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
      * @param action
      *            the {@link Action2} to convert
      * @return a {@link Func2} that calls {@code action} and returns {@code null}
@@ -127,6 +130,9 @@ public static <T1, T2> Func2<T1, T2, Void> toFunc(final Action2<T1, T2> action)
     /**
      * Converts an {@link Action3} to a function that calls the action and returns {@code null}.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
      * @param action
      *            the {@link Action3} to convert
      * @return a {@link Func3} that calls {@code action} and returns {@code null}
@@ -138,6 +144,10 @@ public static <T1, T2, T3> Func3<T1, T2, T3, Void> toFunc(final Action3<T1, T2,
     /**
      * Converts an {@link Action4} to a function that calls the action and returns {@code null}.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
      * @param action
      *            the {@link Action4} to convert
      * @return a {@link Func4} that calls {@code action} and returns {@code null}
@@ -149,6 +159,11 @@ public static <T1, T2, T3, T4> Func4<T1, T2, T3, T4, Void> toFunc(final Action4<
     /**
      * Converts an {@link Action5} to a function that calls the action and returns {@code null}.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
+     * @param <T5> the fifth argument type
      * @param action
      *            the {@link Action5} to convert
      * @return a {@link Func5} that calls {@code action} and returns {@code null}
@@ -161,6 +176,12 @@ public static <T1, T2, T3, T4, T5> Func5<T1, T2, T3, T4, T5, Void> toFunc(
     /**
      * Converts an {@link Action6} to a function that calls the action and returns {@code null}.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
+     * @param <T5> the fifth argument type
+     * @param <T6> the sixth argument type
      * @param action
      *            the {@link Action6} to convert
      * @return a {@link Func6} that calls {@code action} and returns {@code null}
@@ -173,6 +194,13 @@ public static <T1, T2, T3, T4, T5, T6> Func6<T1, T2, T3, T4, T5, T6, Void> toFun
     /**
      * Converts an {@link Action7} to a function that calls the action and returns {@code null}.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
+     * @param <T5> the fifth argument type
+     * @param <T6> the sixth argument type
+     * @param <T7> the seventh argument type
      * @param action
      *            the {@link Action7} to convert
      * @return a {@link Func7} that calls {@code action} and returns {@code null}
@@ -185,6 +213,14 @@ public static <T1, T2, T3, T4, T5, T6, T7> Func7<T1, T2, T3, T4, T5, T6, T7, Voi
     /**
      * Converts an {@link Action8} to a function that calls the action and returns {@code null}.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
+     * @param <T5> the fifth argument type
+     * @param <T6> the sixth argument type
+     * @param <T7> the seventh argument type
+     * @param <T8> the eigth argument type
      * @param action
      *            the {@link Action8} to convert
      * @return a {@link Func8} that calls {@code action} and returns {@code null}
@@ -197,6 +233,15 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> Func8<T1, T2, T3, T4, T5, T6, T7,
     /**
      * Converts an {@link Action9} to a function that calls the action and returns {@code null}.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
+     * @param <T5> the fifth argument type
+     * @param <T6> the sixth argument type
+     * @param <T7> the seventh argument type
+     * @param <T8> the eigth argument type
+     * @param <T9> the ninth argument type
      * @param action
      *            the {@link Action9} to convert
      * @return a {@link Func9} that calls {@code action} and returns {@code null}
@@ -221,6 +266,7 @@ public static FuncN<Void> toFunc(
     /**
      * Converts an {@link Action0} to a function that calls the action and returns a specified value.
      * 
+     * @param <R> the result type
      * @param action
      *            the {@link Action0} to convert
      * @param result
@@ -240,6 +286,8 @@ public R call() {
     /**
      * Converts an {@link Action1} to a function that calls the action and returns a specified value.
      * 
+     * @param <T1> the first argument type
+     * @param <R> the result type
      * @param action
      *            the {@link Action1} to convert
      * @param result
@@ -259,6 +307,9 @@ public R call(T1 t1) {
     /**
      * Converts an {@link Action2} to a function that calls the action and returns a specified value.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <R> the result type
      * @param action
      *            the {@link Action2} to convert
      * @param result
@@ -278,6 +329,10 @@ public R call(T1 t1, T2 t2) {
     /**
      * Converts an {@link Action3} to a function that calls the action and returns a specified value.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <R> the result type
      * @param action
      *            the {@link Action3} to convert
      * @param result
@@ -297,6 +352,11 @@ public R call(T1 t1, T2 t2, T3 t3) {
     /**
      * Converts an {@link Action4} to a function that calls the action and returns a specified value.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
+     * @param <R> the result type
      * @param action
      *            the {@link Action4} to convert
      * @param result
@@ -316,6 +376,12 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4) {
     /**
      * Converts an {@link Action5} to a function that calls the action and returns a specified value.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
+     * @param <T5> the fifth argument type
+     * @param <R> the result type
      * @param action
      *            the {@link Action5} to convert
      * @param result
@@ -336,6 +402,13 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
     /**
      * Converts an {@link Action6} to a function that calls the action and returns a specified value.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
+     * @param <T5> the fifth argument type
+     * @param <T6> the sixth argument type
+     * @param <R> the result type
      * @param action
      *            the {@link Action6} to convert
      * @param result
@@ -356,6 +429,14 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) {
     /**
      * Converts an {@link Action7} to a function that calls the action and returns a specified value.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
+     * @param <T5> the fifth argument type
+     * @param <T6> the sixth argument type
+     * @param <T7> the seventh argument type
+     * @param <R> the result type
      * @param action
      *            the {@link Action7} to convert
      * @param result
@@ -376,6 +457,15 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) {
     /**
      * Converts an {@link Action8} to a function that calls the action and returns a specified value.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
+     * @param <T5> the fifth argument type
+     * @param <T6> the sixth argument type
+     * @param <T7> the seventh argument type
+     * @param <T8> the eigth argument type
+     * @param <R> the result type
      * @param action
      *            the {@link Action8} to convert
      * @param result
@@ -396,6 +486,16 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) {
     /**
      * Converts an {@link Action9} to a function that calls the action and returns a specified value.
      * 
+     * @param <T1> the first argument type
+     * @param <T2> the second argument type
+     * @param <T3> the third argument type
+     * @param <T4> the fourth argument type
+     * @param <T5> the fifth argument type
+     * @param <T6> the sixth argument type
+     * @param <T7> the seventh argument type
+     * @param <T8> the eigth argument type
+     * @param <T9> the ninth argument type
+     * @param <R> the result type
      * @param action
      *            the {@link Action9} to convert
      * @param result
@@ -416,6 +516,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9) {
     /**
      * Converts an {@link ActionN} to a function that calls the action and returns a specified value.
      * 
+     * @param <R> the result type
      * @param action
      *            the {@link ActionN} to convert
      * @param result
@@ -436,6 +537,7 @@ public R call(Object... args) {
     /**
      * Wraps an Action0 instance into an Action1 instance where the latter calls
      * the former.
+     * @param <T> the first argument type
      * @param action the action to call
      * @return the new Action1 instance
      */
diff --git a/src/main/java/rx/functions/Func0.java b/src/main/java/rx/functions/Func0.java
index 96df934066..fc9e10981b 100644
--- a/src/main/java/rx/functions/Func0.java
+++ b/src/main/java/rx/functions/Func0.java
@@ -19,6 +19,7 @@
 
 /**
  * Represents a function with zero arguments.
+ * @param <R> the result type
  */
 public interface Func0<R> extends Function, Callable<R> {
     @Override
diff --git a/src/main/java/rx/functions/Func1.java b/src/main/java/rx/functions/Func1.java
index 54fbd98705..64ffae0c60 100644
--- a/src/main/java/rx/functions/Func1.java
+++ b/src/main/java/rx/functions/Func1.java
@@ -17,6 +17,8 @@
 
 /**
  * Represents a function with one argument.
+ * @param <T> the first argument type
+ * @param <R> the result type
  */
 public interface Func1<T, R> extends Function {
     R call(T t);
diff --git a/src/main/java/rx/functions/Func2.java b/src/main/java/rx/functions/Func2.java
index b44aeed76e..660a11b79c 100644
--- a/src/main/java/rx/functions/Func2.java
+++ b/src/main/java/rx/functions/Func2.java
@@ -17,6 +17,9 @@
 
 /**
  * Represents a function with two arguments.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <R> the result type
  */
 public interface Func2<T1, T2, R> extends Function {
     R call(T1 t1, T2 t2);
diff --git a/src/main/java/rx/functions/Func3.java b/src/main/java/rx/functions/Func3.java
index a47cbaf893..0029ceebfb 100644
--- a/src/main/java/rx/functions/Func3.java
+++ b/src/main/java/rx/functions/Func3.java
@@ -17,6 +17,10 @@
 
 /**
  * Represents a function with three arguments.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <R> the result type
  */
 public interface Func3<T1, T2, T3, R> extends Function {
     R call(T1 t1, T2 t2, T3 t3);
diff --git a/src/main/java/rx/functions/Func4.java b/src/main/java/rx/functions/Func4.java
index b07ea63d99..0daca118ee 100644
--- a/src/main/java/rx/functions/Func4.java
+++ b/src/main/java/rx/functions/Func4.java
@@ -17,6 +17,11 @@
 
 /**
  * Represents a function with four arguments.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
+ * @param <R> the result type
  */
 public interface Func4<T1, T2, T3, T4, R> extends Function {
     R call(T1 t1, T2 t2, T3 t3, T4 t4);
diff --git a/src/main/java/rx/functions/Func5.java b/src/main/java/rx/functions/Func5.java
index 30016c7eaf..7385065452 100644
--- a/src/main/java/rx/functions/Func5.java
+++ b/src/main/java/rx/functions/Func5.java
@@ -17,6 +17,12 @@
 
 /**
  * Represents a function with five arguments.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
+ * @param <T5> the fifth argument type
+ * @param <R> the result type
  */
 public interface Func5<T1, T2, T3, T4, T5, R> extends Function {
     R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5);
diff --git a/src/main/java/rx/functions/Func6.java b/src/main/java/rx/functions/Func6.java
index e74af30733..9a8e2a436b 100644
--- a/src/main/java/rx/functions/Func6.java
+++ b/src/main/java/rx/functions/Func6.java
@@ -17,6 +17,13 @@
 
 /**
  * Represents a function with six arguments.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
+ * @param <T5> the fifth argument type
+ * @param <T6> the sixth argument type
+ * @param <R> the result type
  */
 public interface Func6<T1, T2, T3, T4, T5, T6, R> extends Function {
     R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6);
diff --git a/src/main/java/rx/functions/Func7.java b/src/main/java/rx/functions/Func7.java
index 181e504df0..79d23a829d 100644
--- a/src/main/java/rx/functions/Func7.java
+++ b/src/main/java/rx/functions/Func7.java
@@ -17,6 +17,14 @@
 
 /**
  * Represents a function with seven arguments.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
+ * @param <T5> the fifth argument type
+ * @param <T6> the sixth argument type
+ * @param <T7> the seventh argument type
+ * @param <R> the result type
  */
 public interface Func7<T1, T2, T3, T4, T5, T6, T7, R> extends Function {
     R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7);
diff --git a/src/main/java/rx/functions/Func8.java b/src/main/java/rx/functions/Func8.java
index 1f49817d12..a64df6806e 100644
--- a/src/main/java/rx/functions/Func8.java
+++ b/src/main/java/rx/functions/Func8.java
@@ -17,6 +17,15 @@
 
 /**
  * Represents a function with eight arguments.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
+ * @param <T5> the fifth argument type
+ * @param <T6> the sixth argument type
+ * @param <T7> the seventh argument type
+ * @param <T8> the eigth argument type
+ * @param <R> the result type
  */
 public interface Func8<T1, T2, T3, T4, T5, T6, T7, T8, R> extends Function {
     R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8);
diff --git a/src/main/java/rx/functions/Func9.java b/src/main/java/rx/functions/Func9.java
index 56deac6119..35c96f93f3 100644
--- a/src/main/java/rx/functions/Func9.java
+++ b/src/main/java/rx/functions/Func9.java
@@ -17,6 +17,16 @@
 
 /**
  * Represents a function with nine arguments.
+ * @param <T1> the first argument type
+ * @param <T2> the second argument type
+ * @param <T3> the third argument type
+ * @param <T4> the fourth argument type
+ * @param <T5> the fifth argument type
+ * @param <T6> the sixth argument type
+ * @param <T7> the seventh argument type
+ * @param <T8> the eigth argument type
+ * @param <T9> the ninth argument type
+ * @param <R> the result type
  */
 public interface Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> extends Function {
     R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9);
diff --git a/src/main/java/rx/functions/FuncN.java b/src/main/java/rx/functions/FuncN.java
index 72d1742d40..e78e57a42d 100644
--- a/src/main/java/rx/functions/FuncN.java
+++ b/src/main/java/rx/functions/FuncN.java
@@ -17,6 +17,7 @@
 
 /**
  * Represents a vector-argument function.
+ * @param <R> the result type
  */
 public interface FuncN<R> extends Function {
     R call(Object... args);
diff --git a/src/main/java/rx/functions/Functions.java b/src/main/java/rx/functions/Functions.java
index 4eb7ca111a..b22df29204 100644
--- a/src/main/java/rx/functions/Functions.java
+++ b/src/main/java/rx/functions/Functions.java
@@ -23,6 +23,7 @@ private Functions() {
     /**
      * Converts a {@link Func0} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <R> the result type
      * @param f
      *          the {@code Func0} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -44,6 +45,8 @@ public R call(Object... args) {
     /**
      * Converts a {@link Func1} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
+     * @param <R> the result type
      * @param f
      *          the {@code Func1} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -66,6 +69,9 @@ public R call(Object... args) {
     /**
      * Converts a {@link Func2} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
+     * @param <T1> the second argument type
+     * @param <R> the result type
      * @param f
      *          the {@code Func2} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -88,6 +94,10 @@ public R call(Object... args) {
     /**
      * Converts a {@link Func3} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
+     * @param <T1> the second argument type
+     * @param <T2> the third argument type
+     * @param <R> the result type
      * @param f
      *          the {@code Func3} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -110,6 +120,11 @@ public R call(Object... args) {
     /**
      * Converts a {@link Func4} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
+     * @param <T1> the second argument type
+     * @param <T2> the third argument type
+     * @param <T3> the fourth argument type
+     * @param <R> the result type
      * @param f
      *          the {@code Func4} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -132,6 +147,12 @@ public R call(Object... args) {
     /**
      * Converts a {@link Func5} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
+     * @param <T1> the second argument type
+     * @param <T2> the third argument type
+     * @param <T3> the fourth argument type
+     * @param <T4> the fifth argument type
+     * @param <R> the result type
      * @param f
      *          the {@code Func5} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -154,6 +175,13 @@ public R call(Object... args) {
     /**
      * Converts a {@link Func6} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
+     * @param <T1> the second argument type
+     * @param <T2> the third argument type
+     * @param <T3> the fourth argument type
+     * @param <T4> the fifth argument type
+     * @param <T5> the sixth argument type
+     * @param <R> the result type
      * @param f
      *          the {@code Func6} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -176,6 +204,14 @@ public R call(Object... args) {
     /**
      * Converts a {@link Func7} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
+     * @param <T1> the second argument type
+     * @param <T2> the third argument type
+     * @param <T3> the fourth argument type
+     * @param <T4> the fifth argument type
+     * @param <T5> the sixth argument type
+     * @param <T6> the seventh argument type
+     * @param <R> the result type
      * @param f
      *          the {@code Func7} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -198,6 +234,15 @@ public R call(Object... args) {
     /**
      * Converts a {@link Func8} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
+     * @param <T1> the second argument type
+     * @param <T2> the third argument type
+     * @param <T3> the fourth argument type
+     * @param <T4> the fifth argument type
+     * @param <T5> the sixth argument type
+     * @param <T6> the seventh argument type
+     * @param <T7> the eigth argument type
+     * @param <R> the result type
      * @param f
      *          the {@code Func8} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -220,6 +265,16 @@ public R call(Object... args) {
     /**
      * Converts a {@link Func9} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
+     * @param <T1> the second argument type
+     * @param <T2> the third argument type
+     * @param <T3> the fourth argument type
+     * @param <T4> the fifth argument type
+     * @param <T5> the sixth argument type
+     * @param <T6> the seventh argument type
+     * @param <T7> the eigth argument type
+     * @param <T8> the ninth argument type
+     * @param <R> the result type
      * @param f
      *          the {@code Func9} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -264,6 +319,7 @@ public Void call(Object... args) {
     /**
      * Converts an {@link Action1} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
      * @param f
      *          the {@code Action1} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -287,6 +343,8 @@ public Void call(Object... args) {
     /**
      * Converts an {@link Action2} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
+     * @param <T1> the second argument type
      * @param f
      *          the {@code Action2} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -310,6 +368,9 @@ public Void call(Object... args) {
     /**
      * Converts an {@link Action3} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
      * 
+     * @param <T0> the first argument type
+     * @param <T1> the second argument type
+     * @param <T2> the third argument type
      * @param f
      *          the {@code Action3} to convert
      * @return a {@link FuncN} representation of {@code f}
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
index b53ab211a7..d744da2c02 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
@@ -98,7 +98,6 @@ public boolean hasNext() {
                         throw Exceptions.propagate(ex);
                     }
 
-                    @SuppressWarnings("unchecked")
                     Notification<? extends T> n = value.getAndSet(null);
                     iNotif = n;
                     if (iNotif.isOnError()) {
diff --git a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
index 5e794de018..0ba5bfab61 100644
--- a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
+++ b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
@@ -60,6 +60,8 @@ public static <T> BufferUntilSubscriber<T> create() {
 
     /** The common state. */
     static final class State<T> extends AtomicReference<Observer<? super T>> {
+        /** */
+        private static final long serialVersionUID = 8026705089538090368L;
         boolean casObserverRef(Observer<? super T>  expected, Observer<? super T>  next) {
             return compareAndSet(expected, next);
         }
diff --git a/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java b/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
index 0b0ee1c8f7..393a72dfdd 100644
--- a/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
+++ b/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
@@ -20,7 +20,6 @@
 import rx.SingleSubscriber;
 import rx.exceptions.Exceptions;
 import rx.functions.Func1;
-import rx.plugins.RxJavaPlugins;
 
 public class SingleOperatorOnErrorResumeNext<T> implements Single.OnSubscribe<T> {
 
diff --git a/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java b/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
index 8f4a5f34a2..fb813412db 100644
--- a/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
+++ b/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
@@ -88,6 +88,7 @@ public void shutdown() {
     /**
      * Create a scheduler with pool size equal to the available processor
      * count and using least-recent worker selection policy.
+     * @param threadFactory the factory to use with the executors
      */
     public EventLoopsScheduler(ThreadFactory threadFactory) {
         this.threadFactory = threadFactory;
diff --git a/src/main/java/rx/internal/schedulers/ExecutorScheduler.java b/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
index b40c0b4900..a57ee8c938 100644
--- a/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
+++ b/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
@@ -35,10 +35,6 @@ public ExecutorScheduler(Executor executor) {
         this.executor = executor;
     }
 
-    /**
-     * @warn javadoc missing
-     * @return
-     */
     @Override
     public Worker createWorker() {
         return new ExecutorSchedulerWorker(executor);
diff --git a/src/main/java/rx/internal/schedulers/NewThreadWorker.java b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
index 0103a609ff..585d27b3b6 100644
--- a/src/main/java/rx/internal/schedulers/NewThreadWorker.java
+++ b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
@@ -225,11 +225,12 @@ public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit
     }
 
     /**
-     * @warn javadoc missing
-     * @param action
-     * @param delayTime
-     * @param unit
-     * @return
+     * Schedules the given action by wrapping it into a ScheduledAction on the
+     * underlying ExecutorService, returning the ScheduledAction. 
+     * @param action the action to wrap and schedule
+     * @param delayTime the delay in execution
+     * @param unit the time unit of the delay
+     * @return the wrapper ScheduledAction
      */
     public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit) {
         Action0 decoratedAction = schedulersHook.onSchedule(action);
diff --git a/src/main/java/rx/internal/util/BackpressureDrainManager.java b/src/main/java/rx/internal/util/BackpressureDrainManager.java
index 3e670e0e53..08bb3beb58 100644
--- a/src/main/java/rx/internal/util/BackpressureDrainManager.java
+++ b/src/main/java/rx/internal/util/BackpressureDrainManager.java
@@ -29,6 +29,8 @@
  */
 @Experimental
 public final class BackpressureDrainManager extends AtomicLong implements Producer {
+    /** */
+    private static final long serialVersionUID = 2826241102729529449L;
     /**
      * Interface representing the minimal callbacks required
      * to operate the drain part of a backpressure system.
diff --git a/src/main/java/rx/internal/util/IndexedRingBuffer.java b/src/main/java/rx/internal/util/IndexedRingBuffer.java
index 73f921b30d..d434662866 100644
--- a/src/main/java/rx/internal/util/IndexedRingBuffer.java
+++ b/src/main/java/rx/internal/util/IndexedRingBuffer.java
@@ -296,8 +296,8 @@ public void unsubscribe() {
     /**
      * Add an element and return the index where it was added to allow removal.
      * 
-     * @param e
-     * @return
+     * @param e the element to add
+     * @return the index where the element was added
      */
     public int add(E e) {
         int i = getIndexForAdd();
@@ -429,9 +429,10 @@ public int forEach(Func1<? super E, Boolean> action) {
     }
 
     /**
-     * 
+     * Loop through each element in the buffer and call a specific function.
      * @param action
      *            that processes each item and returns true if it wants to continue to the next
+     * @param startIndex at which index the loop should start
      * @return int of next index to process, or last index seen if it exited early
      */
     public int forEach(Func1<? super E, Boolean> action, int startIndex) {
diff --git a/src/main/java/rx/internal/util/InternalObservableUtils.java b/src/main/java/rx/internal/util/InternalObservableUtils.java
index 0e8e3d6878..0a72b2fd6d 100644
--- a/src/main/java/rx/internal/util/InternalObservableUtils.java
+++ b/src/main/java/rx/internal/util/InternalObservableUtils.java
@@ -163,6 +163,8 @@ public Void call(Object t) {
     /**
      * Creates a Func1 which calls the selector function with the received argument, applies an
      * observeOn on the result and returns the resulting Observable.
+     * @param <T> the input value type
+     * @param <R> the output value type
      * @param selector the selector function
      * @param scheduler the scheduler to apply on the output of the selector
      * @return the new Func1 instance
@@ -226,6 +228,7 @@ public Throwable call(Notification<?> t) {
     
     /**
      * Returns a Func0 that supplies the ConnectableObservable returned by calling replay() on the source.
+     * @param <T> the input value type
      * @param source the source to call replay on by the supplier function
      * @return the new Func0 instance
      */
@@ -247,6 +250,7 @@ public ConnectableObservable<T> call() {
     }
     /**
      * Returns a Func0 that supplies the ConnectableObservable returned by calling a parameterized replay() on the source.
+     * @param <T> the input value type
      * @param source the source to call replay on by the supplier function
      * @param bufferSize
      *            the buffer size that limits the number of items the connectable observable can replay
@@ -273,14 +277,17 @@ public ConnectableObservable<T> call() {
 
     /**
      * Returns a Func0 that supplies the ConnectableObservable returned by calling a parameterized replay() on the source.
+     * @param <T> the input value type
      * @param source the source to call replay on by the supplier function
      * @param time
      *            the duration of the window in which the replayed items must have been emitted
      * @param unit
      *            the time unit of {@code time}
+     * @param scheduler the scheduler to use for timing information
      * @return the new Func0 instance
      */
-    public static <T> Func0<ConnectableObservable<T>> createReplaySupplier(final Observable<T> source, final long time, final TimeUnit unit, final Scheduler scheduler) {
+    public static <T> Func0<ConnectableObservable<T>> createReplaySupplier(final Observable<T> source, 
+            final long time, final TimeUnit unit, final Scheduler scheduler) {
         return new ReplaySupplierBufferTime<T>(source, time, unit, scheduler);
     }
 
@@ -305,6 +312,7 @@ public ConnectableObservable<T> call() {
 
     /**
      * Returns a Func0 that supplies the ConnectableObservable returned by calling a parameterized replay() on the source.
+     * @param <T> the input value type
      * @param source the source to call replay on by the supplier function
      * @param bufferSize
      *            the buffer size that limits the number of items the connectable observable can replay
@@ -312,9 +320,11 @@ public ConnectableObservable<T> call() {
      *            the duration of the window in which the replayed items must have been emitted
      * @param unit
      *            the time unit of {@code time}
+     * @param scheduler the scheduler to use for timing information
      * @return the new Func0 instance
      */
-    public static <T> Func0<ConnectableObservable<T>> createReplaySupplier(final Observable<T> source, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) {
+    public static <T> Func0<ConnectableObservable<T>> createReplaySupplier(final Observable<T> source, 
+            final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) {
         return new ReplaySupplierTime<T>(source, bufferSize, time, unit, scheduler);
     }
 
@@ -342,6 +352,8 @@ public ConnectableObservable<T> call() {
 
     /**
      * Returns a Func2 which calls a collector with its parameters and returns the first (R) parameter.
+     * @param <T> the input value type
+     * @param <R> the result value type
      * @param collector the collector action to call
      * @return the new Func2 instance
      */
diff --git a/src/main/java/rx/internal/util/LinkedArrayList.java b/src/main/java/rx/internal/util/LinkedArrayList.java
index 57a1289640..fb4ae68cc2 100644
--- a/src/main/java/rx/internal/util/LinkedArrayList.java
+++ b/src/main/java/rx/internal/util/LinkedArrayList.java
@@ -77,35 +77,35 @@ public void add(Object o) {
     }
     /**
      * Returns the head buffer segment or null if the list is empty.
-     * @return
+     * @return the head object array
      */
     public Object[] head() {
         return head;
     }
     /**
      * Returns the tail buffer segment or null if the list is empty.
-     * @return
+     * @return the tail object array
      */
     public Object[] tail() {
         return tail;
     }
     /**
      * Returns the total size of the list.
-     * @return
+     * @return the total size of the list
      */
     public int size() {
         return size;
     }
     /**
      * Returns the index of the next slot in the tail buffer segment.
-     * @return
+     * @return the index of the next slot in the tail buffer segment
      */
     public int indexInTail() {
         return indexInTail;
     }
     /**
      * Returns the capacity hint that indicates the capacity of each buffer segment.
-     * @return
+     * @return the capacity hint that indicates the capacity of each buffer segment
      */
     public int capacityHint() {
         return capacityHint;
diff --git a/src/main/java/rx/internal/util/PlatformDependent.java b/src/main/java/rx/internal/util/PlatformDependent.java
index 614e327a7e..2aa5f7e184 100644
--- a/src/main/java/rx/internal/util/PlatformDependent.java
+++ b/src/main/java/rx/internal/util/PlatformDependent.java
@@ -36,6 +36,7 @@ public final class PlatformDependent {
 
     /**
      * Returns {@code true} if and only if the current platform is Android.
+     * @return {@code true} if and only if the current platform is Android
      */
     public static boolean isAndroid() {
         return IS_ANDROID;
diff --git a/src/main/java/rx/internal/util/RxThreadFactory.java b/src/main/java/rx/internal/util/RxThreadFactory.java
index 1259f4a9e1..1060c0a94e 100644
--- a/src/main/java/rx/internal/util/RxThreadFactory.java
+++ b/src/main/java/rx/internal/util/RxThreadFactory.java
@@ -19,6 +19,9 @@
 import java.util.concurrent.atomic.AtomicLong;
 
 public final class RxThreadFactory extends AtomicLong implements ThreadFactory {
+    /** */
+    private static final long serialVersionUID = -8841098858898482335L;
+
     public static final ThreadFactory NONE = new ThreadFactory() {
         @Override public Thread newThread(Runnable r) {
             throw new AssertionError("No threads allowed.");
diff --git a/src/main/java/rx/internal/util/UtilityFunctions.java b/src/main/java/rx/internal/util/UtilityFunctions.java
index 2d233a4fb1..cda1757ec1 100644
--- a/src/main/java/rx/internal/util/UtilityFunctions.java
+++ b/src/main/java/rx/internal/util/UtilityFunctions.java
@@ -32,6 +32,7 @@ public final class UtilityFunctions {
     /**
      * Returns a function that always returns {@code true}.
      *
+     * @param <T> the value type
      * @return a {@link Func1} that accepts an Object and returns the Boolean {@code true}
      */
     public static <T> Func1<? super T, Boolean> alwaysTrue() {
@@ -41,6 +42,7 @@ public static <T> Func1<? super T, Boolean> alwaysTrue() {
     /**
      * Returns a function that always returns {@code false}.
      *
+     * @param <T> the value type
      * @return a {@link Func1} that accepts an Object and returns the Boolean {@code false}
      */
     public static <T> Func1<? super T, Boolean> alwaysFalse() {
@@ -50,6 +52,7 @@ public static <T> Func1<? super T, Boolean> alwaysFalse() {
     /**
      * Returns a function that always returns the Object it is passed.
      *
+     * @param <T> the input and output value type
      * @return a {@link Func1} that accepts an Object and returns the same Object
      */
     public static <T> Func1<T, T> identity() {
@@ -82,6 +85,17 @@ public Boolean call(Object o) {
     /**
      * Returns a function that merely returns {@code null}, without side effects.
      *
+     * @param <T0> the first argument type
+     * @param <T1> the second argument type
+     * @param <T2> the third argument type
+     * @param <T3> the fourth argument type
+     * @param <T4> the fifth argument type
+     * @param <T5> the sixth argument type
+     * @param <T6> the seventh argument type
+     * @param <T7> the eigth argument type
+     * @param <T8> the ninth argument type
+     * @param <T9> the thenth first argument type
+     * @param <R> the result type
      * @return a function that returns {@code null}
      */
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java b/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
index f46890b7f1..3775f550bf 100644
--- a/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
+++ b/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
@@ -83,8 +83,6 @@ public final int size() {
      * Queue is empty when producerNode is the same as consumerNode. An alternative implementation would be to observe
      * the producerNode.value is null, which also means an empty queue because only the consumerNode.value is allowed to
      * be null.
-     * 
-     * @see MessagePassingQueue#isEmpty()
      */
     @Override
     public final boolean isEmpty() {
diff --git a/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java b/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
index 261e4c2a1b..31f54bd5ce 100644
--- a/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
+++ b/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
@@ -52,7 +52,6 @@ public MpscLinkedAtomicQueue() {
      * This works because each producer is guaranteed to 'plant' a new node and link the old node. No 2 producers can
      * get the same producer node as part of XCHG guarantee.
      * 
-     * @see MessagePassingQueue#offer(Object)
      * @see java.util.Queue#offer(java.lang.Object)
      */
     @Override
@@ -81,7 +80,6 @@ public final boolean offer(final E nextValue) {
      * This means the consumerNode.value is always null, which is also the starting point for the queue. Because null
      * values are not allowed to be offered this is the only node with it's value set to null at any one time.
      * 
-     * @see MessagePassingQueue#poll()
      * @see java.util.Queue#poll()
      */
     @Override
diff --git a/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
index 00fc1f96f0..1151a7a3a9 100644
--- a/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
@@ -26,6 +26,7 @@
  * A single-producer single-consumer bounded queue with exact capacity tracking.
  * <p>This means that a queue of 10 will allow exactly 10 offers, however, the underlying storage is still power-of-2.
  * <p>The implementation uses field updaters and thus should be platform-safe.
+ * @param <T> the value type held by this queue
  */
 public final class SpscExactAtomicArrayQueue<T> extends AtomicReferenceArray<T> implements Queue<T> {
     /** */
diff --git a/src/main/java/rx/internal/util/atomic/SpscLinkedAtomicQueue.java b/src/main/java/rx/internal/util/atomic/SpscLinkedAtomicQueue.java
index deb1ff7b68..9b73da962a 100644
--- a/src/main/java/rx/internal/util/atomic/SpscLinkedAtomicQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscLinkedAtomicQueue.java
@@ -53,7 +53,6 @@ public SpscLinkedAtomicQueue() {
      * </ol>
      * From this follows that producerNode.next is always null and for all other nodes node.next is not null.
      * 
-     * @see MessagePassingQueue#offer(Object)
      * @see java.util.Queue#offer(java.lang.Object)
      */
     @Override
diff --git a/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
index 54bdfeba5a..36bba49862 100644
--- a/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
@@ -28,6 +28,7 @@
  * structure if the production overshoots the consumption.
  * <p>Note that the minimum capacity of the 'islands' are 8 due to how the look-ahead optimization works.
  * <p>The implementation uses field updaters and thus should be platform-safe.
+ * @param <T> the value type held by this queue
  */
 public final class SpscUnboundedAtomicArrayQueue<T> implements Queue<T> {
     static final int MAX_LOOK_AHEAD_STEP = Integer.getInteger("jctools.spsc.max.lookahead.step", 4096);
diff --git a/src/main/java/rx/observables/AsyncOnSubscribe.java b/src/main/java/rx/observables/AsyncOnSubscribe.java
index c0e5a166b8..56b963429e 100644
--- a/src/main/java/rx/observables/AsyncOnSubscribe.java
+++ b/src/main/java/rx/observables/AsyncOnSubscribe.java
@@ -39,7 +39,7 @@
  *
  * @param <S>
  *            the type of the user-define state used in {@link #generateState() generateState(S)} ,
- *            {@link #next(Object, Long, Subscriber) next(S, Long, Subscriber)}, and
+ *            {@link #next(Object, long, Observer) next(S, Long, Observer)}, and
  *            {@link #onUnsubscribe(Object) onUnsubscribe(S)}.
  * @param <T>
  *            the type of {@code Subscribers} that will be compatible with {@code this}.
@@ -48,7 +48,7 @@
 public abstract class AsyncOnSubscribe<S, T> implements OnSubscribe<T> {
 
     /**
-     * Executed once when subscribed to by a subscriber (via {@link OnSubscribe#call(Subscriber)})
+     * Executed once when subscribed to by a subscriber (via {@link #call(Subscriber)})
      * to produce a state value. This value is passed into {@link #next(Object, long, Observer)
      * next(S state, Observer <T> observer)} on the first iteration. Subsequent iterations of
      * {@code next} will receive the state returned by the previous invocation of {@code next}.
@@ -101,6 +101,8 @@ protected void onUnsubscribe(S state) {
      * Generates a synchronous {@link AsyncOnSubscribe} that calls the provided {@code next}
      * function to generate data to downstream subscribers.
      * 
+     * @param <T> the type of the generated values
+     * @param <S> the type of the associated state with each Subscriber
      * @param generator
      *            generates the initial state value (see {@link #generateState()})
      * @param next
@@ -127,6 +129,8 @@ public S call(S state, Long requested, Observer<Observable<? extends T>> subscri
      * 
      * This overload creates a AsyncOnSubscribe without an explicit clean up step.
      * 
+     * @param <T> the type of the generated values
+     * @param <S> the type of the associated state with each Subscriber
      * @param generator
      *            generates the initial state value (see {@link #generateState()})
      * @param next
@@ -155,6 +159,8 @@ public S call(S state, Long requested, Observer<Observable<? extends T>> subscri
      * Generates a synchronous {@link AsyncOnSubscribe} that calls the provided {@code next}
      * function to generate data to downstream subscribers.
      * 
+     * @param <T> the type of the generated values
+     * @param <S> the type of the associated state with each Subscriber
      * @param generator
      *            generates the initial state value (see {@link #generateState()})
      * @param next
@@ -176,6 +182,8 @@ public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> ge
      * Generates a synchronous {@link AsyncOnSubscribe} that calls the provided {@code next}
      * function to generate data to downstream subscribers.
      * 
+     * @param <T> the type of the generated values
+     * @param <S> the type of the associated state with each Subscriber
      * @param generator
      *            generates the initial state value (see {@link #generateState()})
      * @param next
@@ -197,6 +205,7 @@ public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> ge
      * This overload creates a "state-less" AsyncOnSubscribe which does not have an explicit state
      * value. This should be used when the {@code next} function closes over it's state.
      * 
+     * @param <T> the type of the generated values
      * @param next
      *            produces data to the downstream subscriber (see
      *            {@link #next(Object, long, Observer) next(S, long, Observer)})
@@ -222,6 +231,7 @@ public Void call(Void state, Long requested, Observer<Observable<? extends T>> s
      * This overload creates a "state-less" AsyncOnSubscribe which does not have an explicit state
      * value. This should be used when the {@code next} function closes over it's state.
      * 
+     * @param <T> the type of the generated values
      * @param next
      *            produces data to the downstream subscriber (see
      *            {@link #next(Object, long, Observer) next(S, long, Observer)})
@@ -582,6 +592,7 @@ public void onNext(final Observable<? extends T> t) {
             subscribeBufferToObservable(t);
         }
 
+        @SuppressWarnings("unchecked")
         private void subscribeBufferToObservable(final Observable<? extends T> t) {
             final BufferUntilSubscriber<T> buffer = BufferUntilSubscriber.<T> create();
 
diff --git a/src/main/java/rx/observables/BlockingObservable.java b/src/main/java/rx/observables/BlockingObservable.java
index 33bde77d6a..53991409af 100644
--- a/src/main/java/rx/observables/BlockingObservable.java
+++ b/src/main/java/rx/observables/BlockingObservable.java
@@ -60,6 +60,7 @@ private BlockingObservable(Observable<? extends T> o) {
     /**
      * Converts an {@link Observable} into a {@code BlockingObservable}.
      *
+     * @param <T> the observed value type
      * @param o
      *          the {@link Observable} you want to convert
      * @return a {@code BlockingObservable} version of {@code o}
@@ -99,6 +100,7 @@ public void forEach(final Action1<? super T> onNext) {
          * Use 'subscribe' instead of 'unsafeSubscribe' for Rx contract behavior
          * (see http://reactivex.io/documentation/contract.html) as this is the final subscribe in the chain.
          */
+        @SuppressWarnings("unchecked")
         Subscription subscription = ((Observable<T>)o).subscribe(new Subscriber<T>() {
             @Override
             public void onCompleted() {
@@ -143,6 +145,7 @@ public void onNext(T args) {
      * @return an {@link Iterator} that can iterate over the items emitted by this {@code BlockingObservable}
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX documentation: To</a>
      */
+    @SuppressWarnings({ "unchecked", "cast" })
     public Iterator<T> getIterator() {
         return BlockingOperatorToIterator.toIterator((Observable<T>)o);
     }
@@ -298,6 +301,7 @@ public Iterable<T> mostRecent(T initialValue) {
      *         a new item, whereupon the Iterable returns that item
      * @see <a href="http://reactivex.io/documentation/operators/takelast.html">ReactiveX documentation: TakeLast</a>
      */
+    @SuppressWarnings({ "cast", "unchecked" })
     public Iterable<T> next() {
         return BlockingOperatorNext.next((Observable<T>)o);
     }
@@ -315,6 +319,7 @@ public Iterable<T> next() {
      * @return an Iterable that always returns the latest item emitted by this {@code BlockingObservable}
      * @see <a href="http://reactivex.io/documentation/operators/first.html">ReactiveX documentation: First</a>
      */
+    @SuppressWarnings({ "cast", "unchecked" })
     public Iterable<T> latest() {
         return BlockingOperatorLatest.latest((Observable<T>)o);
     }
@@ -397,6 +402,7 @@ public T singleOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
      * @return a {@link Future} that expects a single item to be emitted by this {@code BlockingObservable}
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX documentation: To</a>
      */
+    @SuppressWarnings({ "cast", "unchecked" })
     public Future<T> toFuture() {
         return BlockingOperatorToFuture.toFuture((Observable<T>)o);
     }
@@ -430,6 +436,7 @@ private T blockForSingle(final Observable<? extends T> observable) {
         final AtomicReference<Throwable> returnException = new AtomicReference<Throwable>();
         final CountDownLatch latch = new CountDownLatch(1);
 
+        @SuppressWarnings("unchecked")
         Subscription subscription = ((Observable<T>)observable).subscribe(new Subscriber<T>() {
             @Override
             public void onCompleted() {
@@ -467,6 +474,7 @@ public void onNext(final T item) {
     public void subscribe() {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] error = { null };
+        @SuppressWarnings("unchecked")
         Subscription s = ((Observable<T>)o).subscribe(new Subscriber<T>() {
             @Override
             public void onNext(T t) {
@@ -504,6 +512,7 @@ public void subscribe(Observer<? super T> observer) {
         final NotificationLite<T> nl = NotificationLite.instance();
         final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();
         
+        @SuppressWarnings("unchecked")
         Subscription s = ((Observable<T>)o).subscribe(new Subscriber<T>() {
             @Override
             public void onNext(T t) {
@@ -552,6 +561,7 @@ public void onCompleted() {
      * The unsubscription and backpressure is composed through.
      * @param subscriber the subscriber to forward events and calls to in the current thread
      */
+    @SuppressWarnings("unchecked")
     @Experimental
     public void subscribe(Subscriber<? super T> subscriber) {
         final NotificationLite<T> nl = NotificationLite.instance();
diff --git a/src/main/java/rx/observables/GroupedObservable.java b/src/main/java/rx/observables/GroupedObservable.java
index 0dccce036d..98b5a3e836 100644
--- a/src/main/java/rx/observables/GroupedObservable.java
+++ b/src/main/java/rx/observables/GroupedObservable.java
@@ -40,7 +40,9 @@ public class GroupedObservable<K, T> extends Observable<T> {
 
     /**
      * Converts an {@link Observable} into a {@code GroupedObservable} with a particular key.
-     *
+     * 
+     * @param <K> the key type
+     * @param <T> the value type
      * @param key
      *            the key to identify the group of items emitted by this {@code GroupedObservable}
      * @param o
@@ -80,6 +82,7 @@ public void call(Subscriber<? super T> s) {
      *            the type of the key
      * @param <T>
      *            the type of the items that this Observable emits
+     * @param key the key value
      * @param f
      *            a function that accepts an {@code Subscriber<T>}, and invokes its {@code onNext}, {@code onError}, and {@code onCompleted} methods as appropriate
      * @return a GroupedObservable that, when a {@link Subscriber} subscribes to it, will execute the specified
diff --git a/src/main/java/rx/observables/SyncOnSubscribe.java b/src/main/java/rx/observables/SyncOnSubscribe.java
index c2ff69e6e8..461abe28d4 100644
--- a/src/main/java/rx/observables/SyncOnSubscribe.java
+++ b/src/main/java/rx/observables/SyncOnSubscribe.java
@@ -24,7 +24,6 @@
 import rx.Subscriber;
 import rx.Subscription;
 import rx.annotations.Beta;
-import rx.annotations.Experimental;
 import rx.exceptions.Exceptions;
 import rx.functions.Action0;
 import rx.functions.Action1;
@@ -42,7 +41,7 @@
  *
  * @param <S>
  *            the type of the user-define state used in {@link #generateState() generateState(S)} ,
- *            {@link #next(Object, Subscriber) next(S, Subscriber)}, and
+ *            {@link #next(Object, Observer) next(S, Subscriber)}, and
  *            {@link #onUnsubscribe(Object) onUnsubscribe(S)}.
  * @param <T>
  *            the type of {@code Subscribers} that will be compatible with {@code this}.
@@ -71,7 +70,7 @@ public final void call(final Subscriber<? super T> subscriber) {
     }
 
     /**
-     * Executed once when subscribed to by a subscriber (via {@link OnSubscribe#call(Subscriber)})
+     * Executed once when subscribed to by a subscriber (via {@link #call(Subscriber)})
      * to produce a state value. This value is passed into {@link #next(Object, Observer) next(S
      * state, Observer <T> observer)} on the first iteration. Subsequent iterations of {@code next}
      * will receive the state returned by the previous invocation of {@code next}.
@@ -120,10 +119,12 @@ protected void onUnsubscribe(S state) {
      * Generates a synchronous {@link SyncOnSubscribe} that calls the provided {@code next} function
      * to generate data to downstream subscribers.
      * 
+     * @param <T> the type of the generated values
+     * @param <S> the type of the associated state with each Subscriber
      * @param generator
      *            generates the initial state value (see {@link #generateState()})
      * @param next
-     *            produces data to the downstream subscriber (see {@link #next(Object, Subscriber)
+     *            produces data to the downstream subscriber (see {@link #next(Object, Observer)
      *            next(S, Subscriber)})
      * @return a SyncOnSubscribe that emits data in a protocol compatible with back-pressure.
      */
@@ -146,10 +147,12 @@ public S call(S state, Observer<? super T> subscriber) {
      * 
      * This overload creates a SyncOnSubscribe without an explicit clean up step.
      * 
+     * @param <T> the type of the generated values
+     * @param <S> the type of the associated state with each Subscriber
      * @param generator
      *            generates the initial state value (see {@link #generateState()})
      * @param next
-     *            produces data to the downstream subscriber (see {@link #next(Object, Subscriber)
+     *            produces data to the downstream subscriber (see {@link #next(Object, Observer)
      *            next(S, Subscriber)})
      * @param onUnsubscribe
      *            clean up behavior (see {@link #onUnsubscribe(Object) onUnsubscribe(S)})
@@ -174,10 +177,12 @@ public S call(S state, Observer<? super T> subscriber) {
      * Generates a synchronous {@link SyncOnSubscribe} that calls the provided {@code next} function
      * to generate data to downstream subscribers.
      * 
+     * @param <T> the type of the generated values
+     * @param <S> the type of the associated state with each Subscriber
      * @param generator
      *            generates the initial state value (see {@link #generateState()})
      * @param next
-     *            produces data to the downstream subscriber (see {@link #next(Object, Subscriber)
+     *            produces data to the downstream subscriber (see {@link #next(Object, Observer)
      *            next(S, Subscriber)})
      * @param onUnsubscribe
      *            clean up behavior (see {@link #onUnsubscribe(Object) onUnsubscribe(S)})
@@ -195,10 +200,12 @@ public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> gen
      * Generates a synchronous {@link SyncOnSubscribe} that calls the provided {@code next} function
      * to generate data to downstream subscribers.
      * 
+     * @param <T> the type of the generated values
+     * @param <S> the type of the associated state with each Subscriber
      * @param generator
      *            generates the initial state value (see {@link #generateState()})
      * @param next
-     *            produces data to the downstream subscriber (see {@link #next(Object, Subscriber)
+     *            produces data to the downstream subscriber (see {@link #next(Object, Observer)
      *            next(S, Subscriber)})
      * @return a SyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
@@ -216,8 +223,9 @@ public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> gen
      * This overload creates a "state-less" SyncOnSubscribe which does not have an explicit state
      * value. This should be used when the {@code next} function closes over it's state.
      * 
+     * @param <T> the type of the generated values
      * @param next
-     *            produces data to the downstream subscriber (see {@link #next(Object, Subscriber)
+     *            produces data to the downstream subscriber (see {@link #next(Object, Observer)
      *            next(S, Subscriber)})
      * @return a SyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
@@ -241,8 +249,9 @@ public Void call(Void state, Observer<? super T> subscriber) {
      * This overload creates a "state-less" SyncOnSubscribe which does not have an explicit state
      * value. This should be used when the {@code next} function closes over it's state.
      * 
+     * @param <T> the type of the generated values
      * @param next
-     *            produces data to the downstream subscriber (see {@link #next(Object, Subscriber)
+     *            produces data to the downstream subscriber (see {@link #next(Object, Observer)
      *            next(S, Subscriber)})
      * @param onUnsubscribe
      *            clean up behavior (see {@link #onUnsubscribe(Object) onUnsubscribe(S)})
diff --git a/src/main/java/rx/observers/Observers.java b/src/main/java/rx/observers/Observers.java
index 8425d62b6c..864d98fbc1 100644
--- a/src/main/java/rx/observers/Observers.java
+++ b/src/main/java/rx/observers/Observers.java
@@ -51,7 +51,7 @@ public final void onNext(Object args) {
      * Returns an inert {@link Observer} that does nothing in response to the emissions or notifications from
      * any {@code Observable} it subscribes to but will throw an exception if its
      * {@link Observer#onError onError} method is called.
-     *
+     * @param <T> the observed value type
      * @return an inert {@code Observer}
      */
     @SuppressWarnings("unchecked")
@@ -64,6 +64,7 @@ public static <T> Observer<T> empty() {
      * {@link Observer#onNext onNext} but ignores {@link Observer#onCompleted onCompleted} notifications; 
      * it will throw an {@link OnErrorNotImplementedException} if {@link Observer#onError onError} is invoked.
      *
+     * @param <T> the observed value type
      * @param onNext
      *          a function that handles each item emitted by an {@code Observable}
      * @throws IllegalArgumentException
@@ -101,6 +102,7 @@ public final void onNext(T args) {
      * {@link Observer#onNext onNext} and handles any {@link Observer#onError onError} notification but ignores
      * an {@link Observer#onCompleted onCompleted} notification.
      * 
+     * @param <T> the observed value type
      * @param onNext
      *          a function that handles each item emitted by an {@code Observable}
      * @param onError
@@ -144,6 +146,7 @@ public final void onNext(T args) {
      * {@link Observer#onNext onNext} and handles any {@link Observer#onError onError} or
      * {@link Observer#onCompleted onCompleted} notifications.
      * 
+     * @param <T> the observed value type
      * @param onNext
      *          a function that handles each item emitted by an {@code Observable}
      * @param onError
diff --git a/src/main/java/rx/observers/Subscribers.java b/src/main/java/rx/observers/Subscribers.java
index 274165181a..1fd99e3f1c 100644
--- a/src/main/java/rx/observers/Subscribers.java
+++ b/src/main/java/rx/observers/Subscribers.java
@@ -32,6 +32,7 @@ private Subscribers() {
      * from any {@code Observable} it subscribes to.  Will throw an {@link OnErrorNotImplementedException} if {@link Subscriber#onError onError} 
      * method is called
      *
+     * @param <T> the observed value type
      * @return an inert {@code Observer}
      */
     public static <T> Subscriber<T> empty() {
@@ -41,6 +42,7 @@ public static <T> Subscriber<T> empty() {
     /**
      * Converts an {@link Observer} into a {@link Subscriber}.
      *
+     * @param <T> the observed value type
      * @param o
      *          the {@link Observer} to convert
      * @return a {@link Subscriber} version of {@code o}
@@ -71,9 +73,10 @@ public void onNext(T t) {
      * {@link Subscriber#onNext onNext} but ignores {@link Subscriber#onCompleted onCompleted} notifications;
      * it will throw an {@link OnErrorNotImplementedException} if {@link Subscriber#onError onError} is invoked.
      *
+     * @param <T> the observed value type
      * @param onNext
      *          a function that handles each item emitted by an {@code Observable}
-     * @throws IllegalArgument Exception
+     * @throws IllegalArgumentException
      *          if {@code onNext} is {@code null}
      * @return a {@code Subscriber} that calls {@code onNext} for each emitted item from the {@code Observable}
      *         the {@code Subscriber} subscribes to
@@ -108,11 +111,12 @@ public final void onNext(T args) {
      * {@link Subscriber#onNext onNext} and handles any {@link Subscriber#onError onError} notification but
      * ignores an {@link Subscriber#onCompleted onCompleted} notification.
      * 
+     * @param <T> the observed value type
      * @param onNext
      *          a function that handles each item emitted by an {@code Observable}
      * @param onError
      *          a function that handles an error notification if one is sent by an {@code Observable}
-     * @throws IllegalArgument Exception
+     * @throws IllegalArgumentException
      *          if either {@code onNext} or {@code onError} are {@code null}
      * @return an {@code Subscriber} that calls {@code onNext} for each emitted item from the {@code Observable}
      *         the {@code Subscriber} subscribes to, and calls {@code onError} if the {@code Observable}
@@ -151,13 +155,14 @@ public final void onNext(T args) {
      * {@link Subscriber#onNext onNext} and handles any {@link Subscriber#onError onError} or
      * {@link Subscriber#onCompleted onCompleted} notifications.
      * 
+     * @param <T> the observed value type
      * @param onNext
      *          a function that handles each item emitted by an {@code Observable}
      * @param onError
      *          a function that handles an error notification if one is sent by an {@code Observable}
      * @param onComplete
      *          a function that handles a sequence complete notification if one is sent by an {@code Observable}
-     * @throws IllegalArgument Exception
+     * @throws IllegalArgumentException
      *          if either {@code onNext}, {@code onError}, or {@code onComplete} are {@code null}
      * @return an {@code Subscriber} that calls {@code onNext} for each emitted item from the {@code Observable}
      *         the {@code Subscriber} subscribes to, calls {@code onError} if the {@code Observable} notifies
@@ -202,6 +207,7 @@ public final void onNext(T args) {
      * <code>subscriber</code> when {@link Subscriber#add(rx.Subscription)} is
      * called.
      * 
+     * @param <T> the observed value type
      * @param subscriber
      *            the Subscriber to wrap.
      * 
diff --git a/src/main/java/rx/observers/TestObserver.java b/src/main/java/rx/observers/TestObserver.java
index 928956980b..83f9b600ef 100644
--- a/src/main/java/rx/observers/TestObserver.java
+++ b/src/main/java/rx/observers/TestObserver.java
@@ -24,6 +24,7 @@
 
 /**
  * Observer usable for unit testing to perform assertions, inspect received events or wrap a mocked Observer.
+ * @param <T> the observed value type
  */
 public class TestObserver<T> implements Observer<T> {
 
diff --git a/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index 0413fe6a32..c7c085c7fe 100644
--- a/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -46,6 +46,7 @@ public abstract class RxJavaObservableExecutionHook {
      * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
      * logging, metrics and other such things and pass through the function.
      * 
+     * @param <T> the value type
      * @param f
      *            original {@link OnSubscribe}<{@code T}> to be executed
      * @return {@link OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
@@ -61,6 +62,8 @@ public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
      * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
      * logging, metrics and other such things and pass through the function.
      * 
+     * @param <T> the value type
+     * @param observableInstance the parent observable instance
      * @param onSubscribe
      *            original {@link OnSubscribe}<{@code T}> to be executed
      * @return {@link OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
@@ -78,6 +81,7 @@ public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableIns
      * This can be used to decorate or replace the {@link Subscription} instance or just perform extra logging,
      * metrics and other such things and pass through the subscription.
      * 
+     * @param <T> the value type
      * @param subscription
      *            original {@link Subscription}
      * @return {@link Subscription} subscription that can be modified, decorated, replaced or just returned as a
@@ -94,6 +98,7 @@ public <T> Subscription onSubscribeReturn(Subscription subscription) {
      * This is <em>not</em> errors emitted via {@link Subscriber#onError(Throwable)} but exceptions thrown when
      * attempting to subscribe to a {@link Func1}<{@link Subscriber}{@code <T>}, {@link Subscription}>.
      * 
+     * @param <T> the value type
      * @param e
      *            Throwable thrown by {@link Observable#subscribe(Subscriber)}
      * @return Throwable that can be decorated, replaced or just returned as a pass through
@@ -110,6 +115,8 @@ public <T> Throwable onSubscribeError(Throwable e) {
      * This can be used to decorate or replace the {@link Operator} instance or just perform extra
      * logging, metrics and other such things and pass through the onSubscribe.
      * 
+     * @param <T> the upstream's value type (input)
+     * @param <R> the downstream's value type (output)
      * @param lift
      *            original {@link Operator}{@code <R, T>}
      * @return {@link Operator}{@code <R, T>} function that can be modified, decorated, replaced or just
diff --git a/src/main/java/rx/plugins/RxJavaSchedulersHook.java b/src/main/java/rx/plugins/RxJavaSchedulersHook.java
index 00ed84e442..e50d6a611e 100644
--- a/src/main/java/rx/plugins/RxJavaSchedulersHook.java
+++ b/src/main/java/rx/plugins/RxJavaSchedulersHook.java
@@ -44,6 +44,7 @@ public class RxJavaSchedulersHook {
 
     /**
      * Create an instance of the default {@link Scheduler} used for {@link Schedulers#computation()}.
+     * @return the created Scheduler instance
      */
     @Experimental
     public static Scheduler createComputationScheduler() {
@@ -53,6 +54,8 @@ public static Scheduler createComputationScheduler() {
     /**
      * Create an instance of the default {@link Scheduler} used for {@link Schedulers#computation()}
      * except using {@code threadFactory} for thread creation.
+     * @param threadFactory the factory to use for each worker thread
+     * @return the created Scheduler instance
      */
     @Experimental
     public static Scheduler createComputationScheduler(ThreadFactory threadFactory) {
@@ -62,6 +65,7 @@ public static Scheduler createComputationScheduler(ThreadFactory threadFactory)
 
     /**
      * Create an instance of the default {@link Scheduler} used for {@link Schedulers#io()}.
+     * @return the created Scheduler instance
      */
     @Experimental
     public static Scheduler createIoScheduler() {
@@ -71,6 +75,8 @@ public static Scheduler createIoScheduler() {
     /**
      * Create an instance of the default {@link Scheduler} used for {@link Schedulers#io()}
      * except using {@code threadFactory} for thread creation.
+     * @param threadFactory the factory to use for each worker thread
+     * @return the created Scheduler instance
      */
     @Experimental
     public static Scheduler createIoScheduler(ThreadFactory threadFactory) {
@@ -80,6 +86,7 @@ public static Scheduler createIoScheduler(ThreadFactory threadFactory) {
 
     /**
      * Create an instance of the default {@link Scheduler} used for {@link Schedulers#newThread()}.
+     * @return the created Scheduler instance
      */
     @Experimental
     public static Scheduler createNewThreadScheduler() {
@@ -89,6 +96,8 @@ public static Scheduler createNewThreadScheduler() {
     /**
      * Create an instance of the default {@link Scheduler} used for {@link Schedulers#newThread()}
      * except using {@code threadFactory} for thread creation.
+     * @param threadFactory the factory to use for each worker thread
+     * @return the created Scheduler instance
      */
     @Experimental
     public static Scheduler createNewThreadScheduler(ThreadFactory threadFactory) {
@@ -107,6 +116,7 @@ protected RxJavaSchedulersHook() {
      * used.
      *
      * This instance should be or behave like a stateless singleton;
+     * @return the current computation scheduler instance
      */
     public Scheduler getComputationScheduler() {
         return null;
@@ -116,6 +126,7 @@ public Scheduler getComputationScheduler() {
      * Scheduler to return from {@link rx.schedulers.Schedulers#io()} or null if default should be used.
      *
      * This instance should be or behave like a stateless singleton;
+     * @return the created Scheduler instance
      */
     public Scheduler getIOScheduler() {
         return null;
@@ -125,6 +136,7 @@ public Scheduler getIOScheduler() {
      * Scheduler to return from {@link rx.schedulers.Schedulers#newThread()} or null if default should be used.
      *
      * This instance should be or behave like a stateless singleton;
+     * @return the current new thread scheduler instance
      */
     public Scheduler getNewThreadScheduler() {
         return null;
diff --git a/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java b/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
index 65c7ad3155..ed780381b8 100644
--- a/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
@@ -45,9 +45,10 @@ public abstract class RxJavaSingleExecutionHook {
      * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
      * logging, metrics and other such things and pass through the function.
      *
+     * @param <T> the value type emitted by Single
      * @param f
-     *            original {@link Single.OnSubscribe}<{@code T}> to be executed
-     * @return {@link Single.OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
+     *            original {@link rx.Single.OnSubscribe}<{@code T}> to be executed
+     * @return {@link rx.Single.OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
     public <T> Single.OnSubscribe<T> onCreate(Single.OnSubscribe<T> f) {
@@ -60,9 +61,11 @@ public <T> Single.OnSubscribe<T> onCreate(Single.OnSubscribe<T> f) {
      * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
      * logging, metrics and other such things and pass through the function.
      *
+     * @param <T> the value type emitted
+     * @param singleInstance the parent single instance
      * @param onSubscribe
-     *            original {@link Observable.OnSubscribe}<{@code T}> to be executed
-     * @return {@link Observable.OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
+     *            original {@link rx.Observable.OnSubscribe}<{@code T}> to be executed
+     * @return {@link rx.Observable.OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
     public <T> Observable.OnSubscribe<T> onSubscribeStart(Single<? extends T> singleInstance, final Observable.OnSubscribe<T> onSubscribe) {
@@ -77,6 +80,7 @@ public <T> Observable.OnSubscribe<T> onSubscribeStart(Single<? extends T> single
      * This can be used to decorate or replace the {@link Subscription} instance or just perform extra logging,
      * metrics and other such things and pass through the subscription.
      *
+     * @param <T> the value type emitted by Single
      * @param subscription
      *            original {@link Subscription}
      * @return {@link Subscription} subscription that can be modified, decorated, replaced or just returned as a
@@ -93,6 +97,7 @@ public <T> Subscription onSubscribeReturn(Subscription subscription) {
      * This is <em>not</em> errors emitted via {@link Subscriber#onError(Throwable)} but exceptions thrown when
      * attempting to subscribe to a {@link Func1}<{@link Subscriber}{@code <T>}, {@link Subscription}>.
      *
+     * @param <T> the value type emitted by Single
      * @param e
      *            Throwable thrown by {@link Single#subscribe(Subscriber)}
      * @return Throwable that can be decorated, replaced or just returned as a pass through
@@ -106,12 +111,14 @@ public <T> Throwable onSubscribeError(Throwable e) {
      * Invoked just as the operator functions is called to bind two operations together into a new
      * {@link Single} and the return value is used as the lifted function
      * <p>
-     * This can be used to decorate or replace the {@link Observable.Operator} instance or just perform extra
+     * This can be used to decorate or replace the {@link rx.Observable.Operator} instance or just perform extra
      * logging, metrics and other such things and pass through the onSubscribe.
      *
+     * @param <T> the upstream value type (input)
+     * @param <R> the downstream value type (output)
      * @param lift
-     *            original {@link Observable.Operator}{@code <R, T>}
-     * @return {@link Observable.Operator}{@code <R, T>} function that can be modified, decorated, replaced or just
+     *            original {@link rx.Observable.Operator}{@code <R, T>}
+     * @return {@link rx.Observable.Operator}{@code <R, T>} function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
     public <T, R> Observable.Operator<? extends R, ? super T> onLift(final Observable.Operator<? extends R, ? super T> lift) {
diff --git a/src/main/java/rx/schedulers/ImmediateScheduler.java b/src/main/java/rx/schedulers/ImmediateScheduler.java
index 3be8edda4a..2696859987 100644
--- a/src/main/java/rx/schedulers/ImmediateScheduler.java
+++ b/src/main/java/rx/schedulers/ImmediateScheduler.java
@@ -21,7 +21,7 @@
  * @deprecated This type was never publicly instantiable. Use {@link Schedulers#immediate()}.
  */
 @Deprecated
-@SuppressWarnings("unused") // Class was part of public API.
+// Class was part of public API.
 public final class ImmediateScheduler extends Scheduler {
     private ImmediateScheduler() {
         throw new AssertionError();
diff --git a/src/main/java/rx/schedulers/NewThreadScheduler.java b/src/main/java/rx/schedulers/NewThreadScheduler.java
index 192f8b29a8..fc709243f0 100644
--- a/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -21,7 +21,7 @@
  * @deprecated This type was never publicly instantiable. Use {@link Schedulers#newThread()}.
  */
 @Deprecated
-@SuppressWarnings("unused") // Class was part of public API.
+// Class was part of public API.
 public final class NewThreadScheduler extends Scheduler {
     private NewThreadScheduler() {
         throw new AssertionError();
diff --git a/src/main/java/rx/schedulers/TimeInterval.java b/src/main/java/rx/schedulers/TimeInterval.java
index ba3a17d03e..2123abaa0b 100644
--- a/src/main/java/rx/schedulers/TimeInterval.java
+++ b/src/main/java/rx/schedulers/TimeInterval.java
@@ -19,6 +19,7 @@
  * A {@code TimeInterval} represents an item emitted by an {@code Observable} along with the amount of time that
  * elapsed either since the emission of the previous item or (if there was no previous item) since the
  * {@code Observable} was first subscribed to.
+ * @param <T> the value type held along with the interval length
  */
 public class TimeInterval<T> {
     private final long intervalInMilliseconds;
diff --git a/src/main/java/rx/schedulers/Timestamped.java b/src/main/java/rx/schedulers/Timestamped.java
index 84b7325ee8..fee18b7976 100644
--- a/src/main/java/rx/schedulers/Timestamped.java
+++ b/src/main/java/rx/schedulers/Timestamped.java
@@ -17,6 +17,7 @@
 
 /**
  * Composite class that takes a value and a timestamp and wraps them.
+ * @param <T> the value type held along with the timestamp
  */
 public final class Timestamped<T> {
     private final long timestampMillis;
diff --git a/src/main/java/rx/schedulers/TrampolineScheduler.java b/src/main/java/rx/schedulers/TrampolineScheduler.java
index 5f708cdc23..bb28916123 100644
--- a/src/main/java/rx/schedulers/TrampolineScheduler.java
+++ b/src/main/java/rx/schedulers/TrampolineScheduler.java
@@ -21,7 +21,7 @@
  * @deprecated This type was never publicly instantiable. Use {@link Schedulers#trampoline()}.
  */
 @Deprecated
-@SuppressWarnings("unused") // Class was part of public API.
+// Class was part of public API.
 public final class TrampolineScheduler extends Scheduler {
     private TrampolineScheduler() {
         throw new AssertionError();
diff --git a/src/main/java/rx/singles/BlockingSingle.java b/src/main/java/rx/singles/BlockingSingle.java
index 9d327f6b6a..1cd0605a33 100644
--- a/src/main/java/rx/singles/BlockingSingle.java
+++ b/src/main/java/rx/singles/BlockingSingle.java
@@ -33,6 +33,8 @@
  * <p/>
  * You construct a {@code BlockingSingle} from a {@code Single} with {@link #from(Single)}
  * or {@link Single#toBlocking()}.
+ * 
+ * @param <T> the value type of the sequence
  */
 @Experimental
 public class BlockingSingle<T> {
@@ -45,6 +47,7 @@ private BlockingSingle(Single<? extends T> single) {
     /**
      * Converts a {@link Single} into a {@code BlockingSingle}.
      *
+     * @param <T> the value type of the sequence
      * @param single the {@link Single} you want to convert
      * @return a {@code BlockingSingle} version of {@code single}
      */
@@ -98,6 +101,7 @@ public void onError(Throwable error) {
      *
      * @return a {@link Future} that returns the value
      */
+    @SuppressWarnings("unchecked")
     @Experimental
     public Future<T> toFuture() {
         return BlockingOperatorToFuture.toFuture(((Single<T>)single).toObservable());
diff --git a/src/main/java/rx/subjects/SerializedSubject.java b/src/main/java/rx/subjects/SerializedSubject.java
index 33b532c7b4..02644d9c9b 100644
--- a/src/main/java/rx/subjects/SerializedSubject.java
+++ b/src/main/java/rx/subjects/SerializedSubject.java
@@ -31,6 +31,9 @@
  * <p><pre>{@code
  * mySafeSubject = new SerializedSubject( myUnsafeSubject );
  * }</pre>
+ * 
+ * @param <T> the input value type
+ * @param <R> the output value type
  */
 public class SerializedSubject<T, R> extends Subject<T, R> {
     private final SerializedObserver<T> observer;
diff --git a/src/main/java/rx/subjects/Subject.java b/src/main/java/rx/subjects/Subject.java
index 94a289139a..f25a6d496b 100644
--- a/src/main/java/rx/subjects/Subject.java
+++ b/src/main/java/rx/subjects/Subject.java
@@ -19,6 +19,8 @@
 
 /**
  * Represents an object that is both an Observable and an Observer.
+ * @param <T> the input value type
+ * @param <R> the output value type
  */
 public abstract class Subject<T, R> extends Observable<R> implements Observer<T> {
     protected Subject(OnSubscribe<R> onSubscribe) {
diff --git a/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 8ac2d59e98..215deb4936 100644
--- a/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -34,6 +34,8 @@
  */
 @SuppressWarnings({"unchecked", "rawtypes"})
 /* package */final class SubjectSubscriptionManager<T> extends AtomicReference<SubjectSubscriptionManager.State<T>> implements OnSubscribe<T> {
+    /** */
+    private static final long serialVersionUID = 6035251036011671568L;
     /** Stores the latest value or the terminal value for some Subjects. */
     volatile Object latest;
     /** Indicates that the subject is active (cheaper than checking the state).*/
diff --git a/src/main/java/rx/subscriptions/RefCountSubscription.java b/src/main/java/rx/subscriptions/RefCountSubscription.java
index 66268670f1..083b860f04 100644
--- a/src/main/java/rx/subscriptions/RefCountSubscription.java
+++ b/src/main/java/rx/subscriptions/RefCountSubscription.java
@@ -126,6 +126,9 @@ void unsubscribeAChild() {
 
     /** The individual sub-subscriptions. */
     private static final class InnerSubscription extends AtomicInteger implements Subscription {
+        /** */
+        private static final long serialVersionUID = 7005765588239987643L;
+        
         final RefCountSubscription parent;
         public InnerSubscription(RefCountSubscription parent) {
             this.parent = parent;
diff --git a/src/test/java/rx/CovarianceTest.java b/src/test/java/rx/CovarianceTest.java
index 6b7a374be8..cca05ae36c 100644
--- a/src/test/java/rx/CovarianceTest.java
+++ b/src/test/java/rx/CovarianceTest.java
@@ -188,6 +188,7 @@ public Observable<Movie> call(Observable<List<Movie>> movieList) {
     };
 
     static Func1<List<List<Movie>>, Observable<Movie>> calculateDelta = new Func1<List<List<Movie>>, Observable<Movie>>() {
+        @Override
         public Observable<Movie> call(List<List<Movie>> listOfLists) {
             if (listOfLists.size() == 1) {
                 return Observable.from(listOfLists.get(0));
diff --git a/src/test/java/rx/ErrorHandlingTests.java b/src/test/java/rx/ErrorHandlingTests.java
index 3facbb1fa0..2da7aea120 100644
--- a/src/test/java/rx/ErrorHandlingTests.java
+++ b/src/test/java/rx/ErrorHandlingTests.java
@@ -29,6 +29,7 @@ public class ErrorHandlingTests {
 
     /**
      * Test that an error from a user provided Observer.onNext is handled and emitted to the onError
+     * @throws InterruptedException on interrupt
      */
     @Test
     public void testOnNextError() throws InterruptedException {
@@ -64,6 +65,7 @@ public void onNext(Long args) {
     /**
      * Test that an error from a user provided Observer.onNext is handled and emitted to the onError
      * even when done across thread boundaries with observeOn
+     * @throws InterruptedException on interrupt
      */
     @Test
     public void testOnNextErrorAcrossThread() throws InterruptedException {
diff --git a/src/test/java/rx/MergeTests.java b/src/test/java/rx/MergeTests.java
index f1501478f6..51f99caaa7 100644
--- a/src/test/java/rx/MergeTests.java
+++ b/src/test/java/rx/MergeTests.java
@@ -17,6 +17,7 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertNotNull;
 
 import java.util.List;
 
@@ -72,7 +73,7 @@ public void testMergeCovariance3() {
 
         assertTrue(values.get(0) instanceof HorrorMovie);
         assertTrue(values.get(1) instanceof Movie);
-        assertTrue(values.get(2) instanceof Media);
+        assertNotNull(values.get(2));
         assertTrue(values.get(3) instanceof HorrorMovie);
     }
 
@@ -96,7 +97,7 @@ public void call(Subscriber<? super Movie> o) {
 
         assertTrue(values.get(0) instanceof HorrorMovie);
         assertTrue(values.get(1) instanceof Movie);
-        assertTrue(values.get(2) instanceof Media);
+        assertNotNull(values.get(2));
         assertTrue(values.get(3) instanceof HorrorMovie);
     }
 
diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
index e0c12b2d37..0865047f3b 100644
--- a/src/test/java/rx/ObservableTests.java
+++ b/src/test/java/rx/ObservableTests.java
@@ -321,6 +321,7 @@ public void testMaterializeDematerializeChaining() {
      * It is handled by the AtomicObserver that wraps the provided Observer.
      * 
      * Result: Passes (if AtomicObserver functionality exists)
+     * @throws InterruptedException on interrupt
      */
     @Test
     public void testCustomObservableWithErrorInObserverAsynchronous() throws InterruptedException {
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index 2520667ccf..fca462407b 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -31,7 +31,6 @@
 import rx.functions.*;
 import rx.observers.SafeSubscriber;
 import rx.observers.TestSubscriber;
-import rx.schedulers.*;
 import rx.plugins.RxJavaPluginsTest;
 import rx.plugins.RxJavaSingleExecutionHook;
 import rx.schedulers.Schedulers;
@@ -292,6 +291,7 @@ public String call(Integer a, Integer b, Integer c, Integer d, Integer e, Intege
     @Test
     public void zipIterableShouldZipListOfSingles() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
+        @SuppressWarnings("unchecked")
         Iterable<Single<Integer>> singles = Arrays.asList(Single.just(1), Single.just(2), Single.just(3));
 
         Single
@@ -396,12 +396,14 @@ public void testMergeWith() {
 
     @Test
     public void testHookCreate() {
-        OnSubscribe subscriber = mock(OnSubscribe.class);
+        @SuppressWarnings("unchecked")
+        OnSubscribe<Object> subscriber = mock(OnSubscribe.class);
         Single.create(subscriber);
 
         verify(hookSpy, times(1)).onCreate(subscriber);
     }
 
+    @SuppressWarnings("unchecked")
     @Test
     public void testHookSubscribeStart() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
@@ -416,6 +418,7 @@ public void testHookSubscribeStart() {
         verify(hookSpy, times(1)).onSubscribeStart(eq(single), any(Observable.OnSubscribe.class));
     }
 
+    @SuppressWarnings("unchecked")
     @Test
     public void testHookUnsafeSubscribeStart() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
@@ -654,6 +657,7 @@ public void call() {
 
     /**
      * Assert that unsubscribe propagates when passing in a SingleSubscriber and not a Subscriber
+     * @throws InterruptedException on interrupt
      */
     @Test
     public void testUnsubscribe2() throws InterruptedException {
@@ -723,6 +727,7 @@ public void call() {
 
     /**
      * Assert that unsubscribe propagates when passing in a SingleSubscriber and not a Subscriber
+     * @throws InterruptedException on interrupt
      */
     @Test
     public void testUnsubscribeViaReturnedSubscription() throws InterruptedException {
@@ -837,6 +842,7 @@ public void toCompletableError() {
 
     @Test
     public void doOnErrorShouldNotCallActionIfNoErrorHasOccurred() {
+        @SuppressWarnings("unchecked")
         Action1<Throwable> action = mock(Action1.class);
 
         TestSubscriber<String> testSubscriber = new TestSubscriber<String>();
@@ -854,6 +860,7 @@ public void doOnErrorShouldNotCallActionIfNoErrorHasOccurred() {
 
     @Test
     public void doOnErrorShouldCallActionIfErrorHasOccurred() {
+        @SuppressWarnings("unchecked")
         Action1<Throwable> action = mock(Action1.class);
 
         TestSubscriber<Object> testSubscriber = new TestSubscriber<Object>();
@@ -873,6 +880,7 @@ public void doOnErrorShouldCallActionIfErrorHasOccurred() {
 
     @Test
     public void doOnErrorShouldThrowCompositeExceptionIfOnErrorActionThrows() {
+        @SuppressWarnings("unchecked")
         Action1<Throwable> action = mock(Action1.class);
 
 
@@ -899,6 +907,7 @@ public void doOnErrorShouldThrowCompositeExceptionIfOnErrorActionThrows() {
 
     @Test
     public void shouldEmitValueFromCallable() throws Exception {
+        @SuppressWarnings("unchecked")
         Callable<String> callable = mock(Callable.class);
 
         when(callable.call()).thenReturn("value");
@@ -917,6 +926,7 @@ public void shouldEmitValueFromCallable() throws Exception {
 
     @Test
     public void shouldPassErrorFromCallable() throws Exception {
+        @SuppressWarnings("unchecked")
         Callable<String> callable = mock(Callable.class);
 
         Throwable error = new IllegalStateException();
@@ -937,6 +947,7 @@ public void shouldPassErrorFromCallable() throws Exception {
 
     @Test
     public void doOnSuccessShouldInvokeAction() {
+        @SuppressWarnings("unchecked")
         Action1<String> action = mock(Action1.class);
 
         TestSubscriber<String> testSubscriber = new TestSubscriber<String>();
@@ -954,6 +965,7 @@ public void doOnSuccessShouldInvokeAction() {
 
     @Test
     public void doOnSuccessShouldPassErrorFromActionToSubscriber() {
+        @SuppressWarnings("unchecked")
         Action1<String> action = mock(Action1.class);
 
         Throwable error = new IllegalStateException();
@@ -974,6 +986,7 @@ public void doOnSuccessShouldPassErrorFromActionToSubscriber() {
 
     @Test
     public void doOnSuccessShouldNotCallActionIfSingleThrowsError() {
+        @SuppressWarnings("unchecked")
         Action1<Object> action = mock(Action1.class);
 
         Throwable error = new IllegalStateException();
@@ -993,6 +1006,7 @@ public void doOnSuccessShouldNotCallActionIfSingleThrowsError() {
 
     @Test
     public void doOnSuccessShouldNotSwallowExceptionThrownByAction() {
+        @SuppressWarnings("unchecked")
         Action1<String> action = mock(Action1.class);
 
         Throwable exceptionFromAction = new IllegalStateException();
@@ -1090,6 +1104,7 @@ public void call(SingleSubscriber<? super Integer> singleSubscriber) {
 
     @Test
     public void deferShouldNotCallFactoryFuncUntilSubscriberSubscribes() throws Exception {
+        @SuppressWarnings("unchecked")
         Callable<Single<Object>> singleFactory = mock(Callable.class);
         Single.defer(singleFactory);
         verifyZeroInteractions(singleFactory);
@@ -1097,6 +1112,7 @@ public void deferShouldNotCallFactoryFuncUntilSubscriberSubscribes() throws Exce
 
     @Test
     public void deferShouldSubscribeSubscriberToSingleFromFactoryFuncAndEmitValue() throws Exception {
+        @SuppressWarnings("unchecked")
         Callable<Single<Object>> singleFactory = mock(Callable.class);
         Object value = new Object();
         Single<Object> single = Single.just(value);
@@ -1117,6 +1133,7 @@ public void deferShouldSubscribeSubscriberToSingleFromFactoryFuncAndEmitValue()
 
     @Test
     public void deferShouldSubscribeSubscriberToSingleFromFactoryFuncAndEmitError() throws Exception {
+        @SuppressWarnings("unchecked")
         Callable<Single<Object>> singleFactory = mock(Callable.class);
         Throwable error = new IllegalStateException();
         Single<Object> single = Single.error(error);
@@ -1137,6 +1154,7 @@ public void deferShouldSubscribeSubscriberToSingleFromFactoryFuncAndEmitError()
 
     @Test
     public void deferShouldPassErrorFromSingleFactoryToTheSubscriber() throws Exception {
+        @SuppressWarnings("unchecked")
         Callable<Single<Object>> singleFactory = mock(Callable.class);
         Throwable errorFromSingleFactory = new IllegalStateException();
         when(singleFactory.call()).thenThrow(errorFromSingleFactory);
@@ -1155,10 +1173,12 @@ public void deferShouldPassErrorFromSingleFactoryToTheSubscriber() throws Except
 
     @Test
     public void deferShouldCallSingleFactoryForEachSubscriber() throws Exception {
+        @SuppressWarnings("unchecked")
         Callable<Single<String>> singleFactory = mock(Callable.class);
 
         String[] values = {"1", "2", "3"};
-        final Single[] singles = new Single[] {Single.just(values[0]), Single.just(values[1]), Single.just(values[2])};
+        @SuppressWarnings("unchecked")
+        final Single<String>[] singles = new Single[] {Single.just(values[0]), Single.just(values[1]), Single.just(values[2])};
 
         final AtomicInteger singleFactoryCallsCounter = new AtomicInteger();
 
@@ -1198,6 +1218,7 @@ public void deferShouldPassNullPointerExceptionToTheSubscriberIfSingleFactoryIsN
 
     @Test
     public void deferShouldPassNullPointerExceptionToTheSubscriberIfSingleFactoryReturnsNull() throws Exception {
+        @SuppressWarnings("unchecked")
         Callable<Single<Object>> singleFactory = mock(Callable.class);
         when(singleFactory.call()).thenReturn(null);
 
@@ -1434,6 +1455,7 @@ public void iterableToArrayShouldThrowNullPointerExceptionIfIterableNull() {
 
     @Test
     public void iterableToArrayShouldConvertList() {
+        @SuppressWarnings("unchecked")
         List<Single<String>> singlesList = Arrays.asList(Single.just("1"), Single.just("2"));
 
         Single<? extends String>[] singlesArray = Single.iterableToArray(singlesList);
diff --git a/src/test/java/rx/exceptions/CompositeExceptionTest.java b/src/test/java/rx/exceptions/CompositeExceptionTest.java
index a08ce23382..cba638e566 100644
--- a/src/test/java/rx/exceptions/CompositeExceptionTest.java
+++ b/src/test/java/rx/exceptions/CompositeExceptionTest.java
@@ -183,6 +183,9 @@ public void testNullElement() {
     @Test(timeout = 1000)
     public void testCompositeExceptionWithUnsupportedInitCause() {
         Throwable t = new Throwable() {
+            /** */
+            private static final long serialVersionUID = -3282577447436848385L;
+
             @Override
             public synchronized Throwable initCause(Throwable cause) {
                 throw new UnsupportedOperationException();
@@ -204,6 +207,9 @@ public synchronized Throwable initCause(Throwable cause) {
     @Test(timeout = 1000)
     public void testCompositeExceptionWithNullInitCause() {
         Throwable t = new Throwable("ThrowableWithNullInitCause") {
+            /** */
+            private static final long serialVersionUID = -7984762607894527888L;
+
             @Override
             public synchronized Throwable initCause(Throwable cause) {
                 return null;
diff --git a/src/test/java/rx/exceptions/ExceptionsTest.java b/src/test/java/rx/exceptions/ExceptionsTest.java
index 9f63e41fa1..c325ab81fc 100644
--- a/src/test/java/rx/exceptions/ExceptionsTest.java
+++ b/src/test/java/rx/exceptions/ExceptionsTest.java
@@ -192,6 +192,7 @@ public void onNext(Object o) {
 
     /**
      * https://github.com/ReactiveX/RxJava/issues/2998
+     * @throws Exception on arbitrary errors
      */
     @Test(expected = OnErrorFailedException.class)
     public void testOnErrorExceptionIsThrownFromGroupBy() throws Exception {
@@ -223,6 +224,7 @@ public void onNext(GroupedObservable<Integer, Integer> integerIntegerGroupedObse
 
     /**
      * https://github.com/ReactiveX/RxJava/issues/2998
+     * @throws Exception on arbitrary errors
      */
     @Test(expected = OnErrorFailedException.class)
     public void testOnErrorExceptionIsThrownFromOnNext() throws Exception {
diff --git a/src/test/java/rx/exceptions/OnNextValueTest.java b/src/test/java/rx/exceptions/OnNextValueTest.java
index 00e5392dab..9342afac60 100644
--- a/src/test/java/rx/exceptions/OnNextValueTest.java
+++ b/src/test/java/rx/exceptions/OnNextValueTest.java
@@ -15,7 +15,6 @@
  */
 package rx.exceptions;
 
-import org.junit.Assert;
 import org.junit.Test;
 
 import rx.Observable;
diff --git a/src/test/java/rx/internal/operators/OperatorConcatTest.java b/src/test/java/rx/internal/operators/OperatorConcatTest.java
index a824374659..d11c16cd6f 100644
--- a/src/test/java/rx/internal/operators/OperatorConcatTest.java
+++ b/src/test/java/rx/internal/operators/OperatorConcatTest.java
@@ -172,6 +172,7 @@ public void testSimpleAsyncConcat() {
 
     /**
      * Test an async Observable that emits more async Observables
+     * @throws Throwable on any error
      */
     @SuppressWarnings("unchecked")
     @Test
diff --git a/src/test/java/rx/internal/operators/OperatorGroupByTest.java b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
index 6ec0aee15f..438595416f 100644
--- a/src/test/java/rx/internal/operators/OperatorGroupByTest.java
+++ b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
@@ -1581,6 +1581,7 @@ public void call(GroupedObservable<Object, Integer> g) {
         ts2.assertNotCompleted();
     }
 
+    @SuppressWarnings("unchecked")
     @Test
     public void testGroupedObservableCollection() {
 
@@ -1637,6 +1638,7 @@ public Observable<List<Integer>> call(GroupedObservable<Boolean, Integer> oddOrE
 
     }
 
+    @SuppressWarnings("unchecked")
     @Test
     public void testCollectedGroups() {
 
diff --git a/src/test/java/rx/internal/operators/OperatorMaterializeTest.java b/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
index 511a79ed54..06f231cf90 100644
--- a/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
@@ -191,7 +191,7 @@ public void call(Object t) {
     @Test
     public void testUnsubscribeJustBeforeCompletionNotificationShouldPreventThatNotificationArriving() {
         TestSubscriber<Notification<Integer>> ts = TestSubscriber.create(0);
-        IllegalArgumentException ex = new IllegalArgumentException();
+
         Observable.<Integer>empty().materialize()
                 .subscribe(ts);
         ts.assertNoValues();
diff --git a/src/test/java/rx/internal/operators/OperatorMergeTest.java b/src/test/java/rx/internal/operators/OperatorMergeTest.java
index b93f32b580..9d938cc002 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeTest.java
@@ -652,6 +652,7 @@ public void onNext(Integer t) {
      * This is the same as the upstreams ones, but now adds the downstream as well by using observeOn.
      * 
      * This requires merge to also obey the Product.request values coming from it's child subscriber.
+     * @throws InterruptedException if the wait is interrupted
      */
     @Test(timeout = 10000)
     public void testBackpressureDownstreamWithConcurrentStreams() throws InterruptedException {
@@ -1334,6 +1335,7 @@ public void testConcurrencyLimit() {
         ts.assertCompleted();
     }
 
+    @SuppressWarnings("unchecked")
     @Test
     public void negativeMaxConcurrent() {
         try {
@@ -1344,6 +1346,7 @@ public void negativeMaxConcurrent() {
         }
     }
 
+    @SuppressWarnings("unchecked")
     @Test
     public void zeroMaxConcurrent() {
         try {
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
index 1489e0c5ae..568ccfd985 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
@@ -28,7 +28,6 @@
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
-import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.internal.util.RxRingBuffer;
 import rx.observers.TestSubscriber;
diff --git a/src/test/java/rx/internal/operators/OperatorRetryTest.java b/src/test/java/rx/internal/operators/OperatorRetryTest.java
index 0941c2d9d4..b80aeef70a 100644
--- a/src/test/java/rx/internal/operators/OperatorRetryTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRetryTest.java
@@ -605,7 +605,10 @@ static final class AsyncObserver<T> implements Observer<T> {
 
         protected Observer<T> target;
 
-        /** Wrap existing Observer */
+        /**
+         * Wrap existing Observer.
+         * @param target the target observer instance
+         */
         public AsyncObserver(Observer<T> target) {
             this.target = target;
         }
@@ -749,7 +752,7 @@ public void run() {
                                     for (Throwable t : ts.getOnErrorEvents()) {
                                         onNextEvents.add(t.toString());
                                     }
-                                    for (Object o : ts.getOnCompletedEvents()) {
+                                    for (int k = 0; k < ts.getOnCompletedEvents().size(); k++) {
                                         onNextEvents.add("onCompleted");
                                     }
                                     data.put(j, onNextEvents);
diff --git a/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java b/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java
index dd56392147..f1c9e47f1b 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java
@@ -147,7 +147,7 @@ public Boolean call(String t) {
         }).subscribe(ts);
         ts.assertTerminalEvent();
         ts.assertNotCompleted();
-        assertEquals(1, (int) ts.getOnErrorEvents().size());
+        assertEquals(1, ts.getOnErrorEvents().size());
         assertTrue(ts.getOnErrorEvents().get(0).getCause().getMessage().contains("abc"));
     }
 }
diff --git a/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java b/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java
index dbb6362401..4368953241 100644
--- a/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java
+++ b/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java
@@ -16,17 +16,13 @@
 
 package rx.internal.schedulers;
 
-import org.junit.Test;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 
-import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledThreadPoolExecutor;
-import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.*;
 
-import static java.lang.reflect.Modifier.FINAL;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import org.junit.Test;
 
 public class NewThreadWorkerTest {
 
@@ -53,7 +49,7 @@ public void findSetRemoveOnCancelPolicyMethodShouldNotFindMethod() {
 
     private static abstract class ScheduledExecutorServiceWithSetRemoveOnCancelPolicy implements ScheduledExecutorService {
         // Just declaration of required method to allow run tests on JDK 6
-        public void setRemoveOnCancelPolicy(@SuppressWarnings("UnusedParameters") boolean value) {}
+        public void setRemoveOnCancelPolicy(boolean value) {}
     }
 
     @Test
diff --git a/src/test/java/rx/internal/util/RxRingBufferSpmcTest.java b/src/test/java/rx/internal/util/RxRingBufferSpmcTest.java
index 9af36a27e8..6129022c54 100644
--- a/src/test/java/rx/internal/util/RxRingBufferSpmcTest.java
+++ b/src/test/java/rx/internal/util/RxRingBufferSpmcTest.java
@@ -38,6 +38,7 @@ protected RxRingBuffer createRingBuffer() {
 
     /**
      * Single producer, 2 consumers. The request() ensures it gets scheduled back on the same Producer thread.
+     * @throws InterruptedException if the wait is interrupted
      */
     @Test
     public void testConcurrency() throws InterruptedException {
diff --git a/src/test/java/rx/internal/util/RxRingBufferSpscTest.java b/src/test/java/rx/internal/util/RxRingBufferSpscTest.java
index 6e33937a57..b1d1962eb0 100644
--- a/src/test/java/rx/internal/util/RxRingBufferSpscTest.java
+++ b/src/test/java/rx/internal/util/RxRingBufferSpscTest.java
@@ -38,6 +38,7 @@ protected RxRingBuffer createRingBuffer() {
 
     /**
      * Single producer, single consumer. The request() ensures it gets scheduled back on the same Producer thread.
+     * @throws InterruptedException if the wait is interrupted
      */
     @Test
     public void testConcurrency() throws InterruptedException {
diff --git a/src/test/java/rx/internal/util/RxRingBufferWithoutUnsafeTest.java b/src/test/java/rx/internal/util/RxRingBufferWithoutUnsafeTest.java
index 3c4409688a..c7d5931887 100644
--- a/src/test/java/rx/internal/util/RxRingBufferWithoutUnsafeTest.java
+++ b/src/test/java/rx/internal/util/RxRingBufferWithoutUnsafeTest.java
@@ -45,6 +45,7 @@ public void testConcurrencyLoop() throws InterruptedException {
     
     /**
      * Single producer, 2 consumers. The request() ensures it gets scheduled back on the same Producer thread.
+     * @throws InterruptedException if the wait is interrupted
      */
     @Test(timeout = 10000)
     public void testConcurrency() throws InterruptedException {
diff --git a/src/test/java/rx/internal/util/ScalarSynchronousSingleTest.java b/src/test/java/rx/internal/util/ScalarSynchronousSingleTest.java
index 61700af4d1..4b9e96c402 100644
--- a/src/test/java/rx/internal/util/ScalarSynchronousSingleTest.java
+++ b/src/test/java/rx/internal/util/ScalarSynchronousSingleTest.java
@@ -280,6 +280,6 @@ public void call(SingleSubscriber<? super String> singleSubscriber) {
     @Test
     public void getValue() {
         Single<Integer> s = Single.just(1);
-        assertEquals(1, ((ScalarSynchronousSingle) s).get());
+        assertEquals(1, ((ScalarSynchronousSingle<?>) s).get());
     }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/observers/SafeSubscriberTest.java b/src/test/java/rx/observers/SafeSubscriberTest.java
index 5ce37cdea4..c11c2b37a0 100644
--- a/src/test/java/rx/observers/SafeSubscriberTest.java
+++ b/src/test/java/rx/observers/SafeSubscriberTest.java
@@ -270,8 +270,8 @@ public void call() {
             safe.onCompleted();
             Assert.fail();
         } catch(UnsubscribeFailedException e) {
-            assertEquals(1, (int) calls.get());
-            assertEquals(0, (int) errors.get());
+            assertEquals(1, calls.get());
+            assertEquals(0, errors.get());
         }
     }
 
@@ -310,8 +310,8 @@ public void call() {
             safe.onCompleted();
             Assert.fail();
         } catch(UnsubscribeFailedException e) {
-            assertEquals(2, (int) calls.get());
-            assertEquals(0, (int) errors.get());
+            assertEquals(2, calls.get());
+            assertEquals(0, errors.get());
         }
     }
 
diff --git a/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 9e3fdf94d3..461ff7cce2 100644
--- a/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -51,6 +51,7 @@ public abstract class AbstractSchedulerConcurrencyTests extends AbstractSchedule
 
     /**
      * Bug report: https://github.com/ReactiveX/RxJava/issues/431
+     * @throws InterruptedException if a wait is interrupted
      */
     @Test
     public final void testUnSubscribeForScheduler() throws InterruptedException {
diff --git a/src/test/java/rx/schedulers/SchedulerTests.java b/src/test/java/rx/schedulers/SchedulerTests.java
index 3a6bb8d632..c07d3078f2 100644
--- a/src/test/java/rx/schedulers/SchedulerTests.java
+++ b/src/test/java/rx/schedulers/SchedulerTests.java
@@ -44,6 +44,9 @@ private SchedulerTests() {
      * <p>
      * Schedulers which execute on a separate thread from their calling thread should exhibit this behavior. Schedulers
      * which execute on their calling thread may not.
+     * 
+     * @param scheduler the scheduler to test
+     * @throws InterruptedException if some wait is interrupted
      */
     public static void testUnhandledErrorIsDeliveredToThreadHandler(Scheduler scheduler) throws InterruptedException {
         Thread.UncaughtExceptionHandler originalHandler = Thread.getDefaultUncaughtExceptionHandler();
@@ -78,6 +81,8 @@ public static void testUnhandledErrorIsDeliveredToThreadHandler(Scheduler schedu
      * <p>
      * This is a companion test to {@link #testUnhandledErrorIsDeliveredToThreadHandler}, and is needed only for the
      * same Schedulers.
+     * @param scheduler the scheduler to test
+     * @throws InterruptedException if some wait is interrupted
      */
     public static void testHandledErrorIsNotDeliveredToThreadHandler(Scheduler scheduler) throws InterruptedException {
         Thread.UncaughtExceptionHandler originalHandler = Thread.getDefaultUncaughtExceptionHandler();
diff --git a/src/test/java/rx/singles/BlockingSingleTest.java b/src/test/java/rx/singles/BlockingSingleTest.java
index 48c5b7eb03..33b892ab4e 100644
--- a/src/test/java/rx/singles/BlockingSingleTest.java
+++ b/src/test/java/rx/singles/BlockingSingleTest.java
@@ -76,5 +76,8 @@ public void testSingleToFuture() throws Exception {
     }
 
     private static final class TestCheckedException extends Exception {
+
+        /** */
+        private static final long serialVersionUID = -5601856891331290034L;
     }
 }
diff --git a/src/test/java/rx/test/OperatorTester.java b/src/test/java/rx/test/OperatorTester.java
index 473a564f50..ad03ad1969 100644
--- a/src/test/java/rx/test/OperatorTester.java
+++ b/src/test/java/rx/test/OperatorTester.java
@@ -37,8 +37,8 @@ private OperatorTester() {
     /**
      * Used for mocking of Schedulers since many Scheduler implementations are static/final.
      * 
-     * @param underlying
-     * @return
+     * @param underlying the actual scheduler
+     * @return the wrapping Scheduler instance
      */
     public static Scheduler forwardingScheduler(Scheduler underlying) {
         return new ForwardingScheduler(underlying);
diff --git a/src/test/java/rx/util/AssertObservable.java b/src/test/java/rx/util/AssertObservable.java
index c8d234b16d..728ea1bfb3 100644
--- a/src/test/java/rx/util/AssertObservable.java
+++ b/src/test/java/rx/util/AssertObservable.java
@@ -28,7 +28,7 @@ private AssertObservable() {
      * Asserts that two Observables are equal. If they are not, an {@link AssertionError} is thrown
      * with the given message. If <code>expecteds</code> and <code>actuals</code> are
      * <code>null</code>, they are considered equal.
-     * 
+     * @param <T> the value tpye
      * @param expected
      *            Observable with expected values.
      * @param actual
@@ -43,6 +43,7 @@ public static <T> void assertObservableEqualsBlocking(Observable<T> expected, Ob
      * with the given message. If <code>expected</code> and <code>actual</code> are
      * <code>null</code>, they are considered equal.
      * 
+     * @param <T> the value tpye
      * @param message
      *            the identifying message for the {@link AssertionError} (<code>null</code> okay)
      * @param expected
@@ -59,12 +60,12 @@ public static <T> void assertObservableEqualsBlocking(String message, Observable
      * they are not, an {@link Observable} is returned that calls onError with an {@link AssertionError} when subscribed to. If <code>expected</code> and <code>actual</code>
      * are <code>null</code>, they are considered equal.
      * 
-     * @param message
-     *            the identifying message for the {@link AssertionError} (<code>null</code> okay)
+     * @param <T> the value tpye
      * @param expected
      *            Observable with expected values.
      * @param actual
      *            Observable with actual values
+     * @return the observable resulting in a complete or error signal.
      */
     public static <T> Observable<Void> assertObservableEquals(Observable<T> expected, Observable<T> actual) {
         return assertObservableEquals(null, expected, actual);
@@ -74,13 +75,15 @@ public static <T> Observable<Void> assertObservableEquals(Observable<T> expected
      * Asserts that two {@link Observable}s are equal and returns an empty {@link Observable}. If
      * they are not, an {@link Observable} is returned that calls onError with an {@link AssertionError} when subscribed to with the given message. If <code>expected</code>
      * and <code>actual</code> are <code>null</code>, they are considered equal.
-     * 
+     *
+     * @param <T> the value type
      * @param message
      *            the identifying message for the {@link AssertionError} (<code>null</code> okay)
      * @param expected
      *            Observable with expected values.
      * @param actual
      *            Observable with actual values
+     * @return the observable resulting in a complete or error signal.
      */
     public static <T> Observable<Void> assertObservableEquals(final String message, Observable<T> expected, Observable<T> actual) {
         if (actual == null && expected != null) {

From d24c395f9ed8507d6df0b469ac9727729c07f671 Mon Sep 17 00:00:00 2001
From: Santiago Castro <bryant@montevideo.com.uy>
Date: Wed, 18 May 2016 19:32:56 -0300
Subject: [PATCH 031/263] Update branches names in CONTRIBUTING:md (#3943)

---
 CONTRIBUTING.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 090f0e8257..7874bbd6b5 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,6 +1,6 @@
 # Contributing to RxJava
 
-If you would like to contribute code you can do so through GitHub by forking the repository and sending a pull request (on a branch other than `master`, `0.x`, `1.x`, or `gh-pages`).
+If you would like to contribute code you can do so through GitHub by forking the repository and sending a pull request (on a branch other than `master`, `1.x`, `2.x`, or `gh-pages`).
 
 When submitting code, please make every effort to follow existing conventions and style in order to keep the code as readable as possible.
 

From 3ea9265dcd63add0ba32eff1c75629f03c1a0443 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 24 May 2016 01:15:32 +0200
Subject: [PATCH 032/263] 1.x: just() construction to call the onCreate
 execution hook (#3958)

This PR adds the call to RxJavaObservableExecutionHook.onCreate() to the just() - ScalarSynchronousObservable construction.

Related: #2656.
---
 .../util/ScalarSynchronousObservable.java     | 32 ++++++---
 .../util/ScalarSynchronousObservableTest.java | 70 ++++++++++++++++++-
 2 files changed, 92 insertions(+), 10 deletions(-)

diff --git a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
index ca6ba3f437..676527f954 100644
--- a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
+++ b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
@@ -23,6 +23,7 @@
 import rx.internal.producers.SingleProducer;
 import rx.internal.schedulers.EventLoopsScheduler;
 import rx.observers.Subscribers;
+import rx.plugins.*;
 
 /**
  * An Observable that emits a single constant scalar value to Subscribers.
@@ -33,6 +34,14 @@
  * @param <T> the value type
  */
 public final class ScalarSynchronousObservable<T> extends Observable<T> {
+    /** 
+     * The execution hook instance. 
+     * <p>
+     * Can't be final to allow tests overriding it in place; if the class
+     * has been initialized, the plugin reset has no effect because
+     * how RxJavaPlugins was designed.
+     */
+    static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
     /**
      * Indicates that the Producer used by this Observable should be fully
      * threadsafe. It is possible, but unlikely that multiple concurrent
@@ -72,14 +81,7 @@ public static <T> ScalarSynchronousObservable<T> create(T t) {
     final T t;
 
     protected ScalarSynchronousObservable(final T t) {
-        super(new OnSubscribe<T>() {
-
-            @Override
-            public void call(Subscriber<? super T> s) {
-                s.setProducer(createProducer(s, t));
-            }
-
-        });
+        super(hook.onCreate(new JustOnSubscribe<T>(t)));
         this.t = t;
     }
 
@@ -131,6 +133,20 @@ public void call() {
         return create(new ScalarAsyncOnSubscribe<T>(t, onSchedule));
     }
     
+    /** The OnSubscribe callback for the Observable constructor. */
+    static final class JustOnSubscribe<T> implements OnSubscribe<T> {
+        final T value;
+
+        JustOnSubscribe(T value) {
+            this.value = value;
+        }
+
+        @Override
+        public void call(Subscriber<? super T> s) {
+            s.setProducer(createProducer(s, value));
+        }
+    }
+
     /**
      * The OnSubscribe implementation that creates the ScalarAsyncProducer for each
      * incoming subscriber.
diff --git a/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java b/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java
index fee7b6f8e1..6898fbd472 100644
--- a/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java
+++ b/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java
@@ -16,12 +16,16 @@
 
 package rx.internal.util;
 
-import org.junit.Test;
+import java.util.concurrent.atomic.*;
 
-import rx.Observable;
+import org.junit.*;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
 import rx.exceptions.TestException;
 import rx.functions.Func1;
 import rx.observers.TestSubscriber;
+import rx.plugins.*;
 import rx.schedulers.Schedulers;
 
 public class ScalarSynchronousObservableTest {
@@ -230,4 +234,66 @@ public void onNext(Integer t) {
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
+    
+    @Test
+    public void hookCalled() {
+        RxJavaObservableExecutionHook save = ScalarSynchronousObservable.hook;
+        try {
+            final AtomicInteger c = new AtomicInteger();
+            
+            ScalarSynchronousObservable.hook = new RxJavaObservableExecutionHook() {
+                @Override
+                public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
+                    c.getAndIncrement();
+                    return f;
+                }
+            };
+            
+            int n = 10;
+            
+            for (int i = 0; i < n; i++) {
+                Observable.just(1).subscribe();
+            }
+            
+            Assert.assertEquals(n, c.get());
+        } finally {
+            ScalarSynchronousObservable.hook = save;
+        }
+    }
+
+    @Test
+    public void hookChangesBehavior() {
+        RxJavaObservableExecutionHook save = ScalarSynchronousObservable.hook;
+        try {
+            ScalarSynchronousObservable.hook = new RxJavaObservableExecutionHook() {
+                @Override
+                public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
+                    if (f instanceof ScalarSynchronousObservable.JustOnSubscribe) {
+                        final T v = ((ScalarSynchronousObservable.JustOnSubscribe<T>) f).value;
+                        return new OnSubscribe<T>() {
+                            @Override
+                            public void call(Subscriber<? super T> t) {
+                                t.onNext(v);
+                                t.onNext(v);
+                                t.onCompleted();
+                            }
+                        };
+                    }
+                    return f;
+                }
+            };
+            
+            TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+            
+            Observable.just(1).subscribe(ts);
+            
+            ts.assertValues(1, 1);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+            
+        } finally {
+            ScalarSynchronousObservable.hook = save;
+        }
+    }
+
 }
\ No newline at end of file

From 7fed2ed89a06ee783c473fdf422a6b159ef00c7a Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 24 May 2016 01:20:20 +0200
Subject: [PATCH 033/263] 1.x: TestSubscriber extra info on assertion failures
 (#3934)

This PR adds extra information to assertion failure messages on `TestSubscriber` and `TestObserver`, indicating:

  - the listener didn't receive any `onCompleted` calls, which is an indication of hung or skipping operation,
  - there were errors received, indicating a failure in the event generation process.

Previously, if there was something wrong with the sequence, the order and type of assertions were mostly unhelpful: if `assertValues` was first, the lack of values failure could hide a revealing onError call. If the `assertNoErrors()` was first, the error is visible but no way of knowing how far the sequence got.

Now, it is generally okay to use `assertValues` first, which along the difference, will print the lack of completion and the number of exceptions received, plus, the `AssertionError` will have its cause initialized to the actual or composited exception. The message format thus changes:

```
original assertion message with details (0 completions) (+1 error)
...
caused by
...
```

This extra information saved me a lot of time in 2.x and Rsc development.

Note that this change doesn't make the `assertXXX`s also assert for completion or error at all. If the values match, but there is an additional error instead of completion, one has to assert that separately, just like now.
---
 src/main/java/rx/observers/TestObserver.java  |  66 +++++++++--
 .../java/rx/observers/TestSubscriber.java     |  20 ++--
 .../java/rx/observers/TestSubscriberTest.java | 104 +++++++++++++++++-
 3 files changed, 165 insertions(+), 25 deletions(-)

diff --git a/src/main/java/rx/observers/TestObserver.java b/src/main/java/rx/observers/TestObserver.java
index 83f9b600ef..baa0f1323d 100644
--- a/src/main/java/rx/observers/TestObserver.java
+++ b/src/main/java/rx/observers/TestObserver.java
@@ -15,12 +15,11 @@
  */
 package rx.observers;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 
 import rx.Notification;
 import rx.Observer;
+import rx.exceptions.CompositeException;
 
 /**
  * Observer usable for unit testing to perform assertions, inspect received events or wrap a mocked Observer.
@@ -114,11 +113,12 @@ public List<Object> getEvents() {
      */
     public void assertReceivedOnNext(List<T> items) {
         if (onNextEvents.size() != items.size()) {
-            throw new AssertionError("Number of items does not match. Provided: " + items.size() + "  Actual: " + onNextEvents.size()
+            assertionError("Number of items does not match. Provided: " + items.size() + "  Actual: " + onNextEvents.size()
             + ".\n"
             + "Provided values: " + items
             + "\n"
-            + "Actual values: " + onNextEvents);
+            + "Actual values: " + onNextEvents
+            + "\n");
         }
 
         for (int i = 0; i < items.size(); i++) {
@@ -127,12 +127,12 @@ public void assertReceivedOnNext(List<T> items) {
             if (expected == null) {
                 // check for null equality
                 if (actual != null) {
-                    throw new AssertionError("Value at index: " + i + " expected to be [null] but was: [" + actual + "]");
+                    assertionError("Value at index: " + i + " expected to be [null] but was: [" + actual + "]\n");
                 }
             } else if (!expected.equals(actual)) {
-                throw new AssertionError("Value at index: " + i 
+                assertionError("Value at index: " + i 
                         + " expected to be [" + expected + "] (" + expected.getClass().getSimpleName() 
-                        + ") but was: [" + actual + "] (" + (actual != null ? actual.getClass().getSimpleName() : "null") + ")");
+                        + ") but was: [" + actual + "] (" + (actual != null ? actual.getClass().getSimpleName() : "null") + ")\n");
 
             }
         }
@@ -147,22 +147,64 @@ public void assertReceivedOnNext(List<T> items) {
      */
     public void assertTerminalEvent() {
         if (onErrorEvents.size() > 1) {
-            throw new AssertionError("Too many onError events: " + onErrorEvents.size());
+            assertionError("Too many onError events: " + onErrorEvents.size());
         }
 
         if (onCompletedEvents.size() > 1) {
-            throw new AssertionError("Too many onCompleted events: " + onCompletedEvents.size());
+            assertionError("Too many onCompleted events: " + onCompletedEvents.size());
         }
 
         if (onCompletedEvents.size() == 1 && onErrorEvents.size() == 1) {
-            throw new AssertionError("Received both an onError and onCompleted. Should be one or the other.");
+            assertionError("Received both an onError and onCompleted. Should be one or the other.");
         }
 
         if (onCompletedEvents.size() == 0 && onErrorEvents.size() == 0) {
-            throw new AssertionError("No terminal events received.");
+            assertionError("No terminal events received.");
         }
     }
 
+    /**
+     * Combines an assertion error message with the current completion and error state of this
+     * TestSubscriber, giving more information when some assertXXX check fails.
+     * @param message the message to use for the error
+     */
+    final void assertionError(String message) {
+        StringBuilder b = new StringBuilder(message.length() + 32);
+        
+        b.append(message);
+        
+        
+        b.append(" (");
+        int c = onCompletedEvents.size();
+        b.append(c);
+        b.append(" completion");
+        if (c != 1) {
+            b.append("s");
+        }
+        b.append(")");
+        
+        if (!onErrorEvents.isEmpty()) {
+            int size = onErrorEvents.size();
+            b.append(" (+")
+            .append(size)
+            .append(" error");
+            if (size != 1) {
+                b.append("s");
+            }
+            b.append(")");
+        }
+        
+        AssertionError ae = new AssertionError(b.toString());
+        if (!onErrorEvents.isEmpty()) {
+            if (onErrorEvents.size() == 1) {
+                ae.initCause(onErrorEvents.get(0));
+            } else {
+                ae.initCause(new CompositeException(onErrorEvents));
+            }
+        }
+        throw ae;
+    }
+    
     // do nothing ... including swallowing errors
     private static Observer<Object> INERT = new Observer<Object>() {
 
diff --git a/src/main/java/rx/observers/TestSubscriber.java b/src/main/java/rx/observers/TestSubscriber.java
index 887bd2998b..5c64b3a8f8 100644
--- a/src/main/java/rx/observers/TestSubscriber.java
+++ b/src/main/java/rx/observers/TestSubscriber.java
@@ -292,7 +292,7 @@ public void assertTerminalEvent() {
      */
     public void assertUnsubscribed() {
         if (!isUnsubscribed()) {
-            throw new AssertionError("Not unsubscribed.");
+            testObserver.assertionError("Not unsubscribed.");
         }
     }
 
@@ -393,10 +393,10 @@ public Thread getLastSeenThread() {
     public void assertCompleted() {
         int s = testObserver.getOnCompletedEvents().size();
         if (s == 0) {
-            throw new AssertionError("Not completed!");
+            testObserver.assertionError("Not completed!");
         } else
         if (s > 1) {
-            throw new AssertionError("Completed multiple times: " + s);
+            testObserver.assertionError("Completed multiple times: " + s);
         }
     }
 
@@ -409,10 +409,10 @@ public void assertCompleted() {
     public void assertNotCompleted() {
         int s = testObserver.getOnCompletedEvents().size();
         if (s == 1) {
-            throw new AssertionError("Completed!");
+            testObserver.assertionError("Completed!");
         } else
         if (s > 1) {
-            throw new AssertionError("Completed multiple times: " + s);
+            testObserver.assertionError("Completed multiple times: " + s);
         }
     }
 
@@ -427,7 +427,7 @@ public void assertNotCompleted() {
     public void assertError(Class<? extends Throwable> clazz) {
         List<Throwable> err = testObserver.getOnErrorEvents();
         if (err.size() == 0) {
-            throw new AssertionError("No errors");
+            testObserver.assertionError("No errors");
         } else
         if (err.size() > 1) {
             AssertionError ae = new AssertionError("Multiple errors: " + err.size());
@@ -452,7 +452,7 @@ public void assertError(Class<? extends Throwable> clazz) {
     public void assertError(Throwable throwable) {
         List<Throwable> err = testObserver.getOnErrorEvents();
         if (err.size() == 0) {
-            throw new AssertionError("No errors");
+            testObserver.assertionError("No errors");
         } else
         if (err.size() > 1) {
             AssertionError ae = new AssertionError("Multiple errors: " + err.size());
@@ -477,7 +477,7 @@ public void assertNoTerminalEvent() {
         int s = testObserver.getOnCompletedEvents().size();
         if (err.size() > 0 || s > 0) {
             if (err.isEmpty()) {
-                throw new AssertionError("Found " + err.size() + " errors and " + s + " completion events instead of none");
+                testObserver.assertionError("Found " + err.size() + " errors and " + s + " completion events instead of none");
             } else
             if (err.size() == 1) {
                 AssertionError ae = new AssertionError("Found " + err.size() + " errors and " + s + " completion events instead of none");
@@ -500,7 +500,7 @@ public void assertNoTerminalEvent() {
     public void assertNoValues() {
         int s = testObserver.getOnNextEvents().size();
         if (s > 0) {
-            throw new AssertionError("No onNext events expected yet some received: " + s);
+            testObserver.assertionError("No onNext events expected yet some received: " + s);
         }
     }
 
@@ -514,7 +514,7 @@ public void assertNoValues() {
     public void assertValueCount(int count) {
         int s = testObserver.getOnNextEvents().size();
         if (s != count) {
-            throw new AssertionError("Number of onNext events differ; expected: " + count + ", actual: " + s);
+            testObserver.assertionError("Number of onNext events differ; expected: " + count + ", actual: " + s);
         }
     }
     
diff --git a/src/test/java/rx/observers/TestSubscriberTest.java b/src/test/java/rx/observers/TestSubscriberTest.java
index 1974a81a2f..9ff09edd20 100644
--- a/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/src/test/java/rx/observers/TestSubscriberTest.java
@@ -18,7 +18,7 @@
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
-import java.util.Arrays;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
@@ -26,8 +26,10 @@
 import org.junit.rules.ExpectedException;
 import org.mockito.InOrder;
 
-import rx.*;
+import rx.Observable;
+import rx.Observer;
 import rx.Scheduler.Worker;
+import rx.Subscriber;
 import rx.exceptions.*;
 import rx.functions.Action0;
 import rx.schedulers.Schedulers;
@@ -610,9 +612,105 @@ public void assertValuesShouldThrowIfNumberOfItemsDoesNotMatch() {
         } catch (AssertionError expected) {
             assertEquals("Number of items does not match. Provided: 2  Actual: 3.\n" +
                     "Provided values: [1, 2]\n" +
-                    "Actual values: [a, b, c]",
+                    "Actual values: [a, b, c]\n (0 completions)",
                     expected.getMessage()
             );
         }
     }
+    
+    @Test
+    public void assertionFailureGivesActiveDetails() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+
+        ts.onNext("a");
+        ts.onNext("b");
+        ts.onNext("c");
+        ts.onError(new TestException("forced failure"));
+
+        try {
+            ts.assertValues("1", "2");
+            fail();
+        } catch (AssertionError expected) {
+            assertEquals("Number of items does not match. Provided: 2  Actual: 3.\n" +
+                    "Provided values: [1, 2]\n" +
+                    "Actual values: [a, b, c]\n (0 completions) (+1 error)",
+                    expected.getMessage()
+            );
+            Throwable ex = expected.getCause();
+            assertEquals(TestException.class, ex.getClass());
+            assertEquals("forced failure", ex.getMessage());
+        }
+    }
+    
+    @Test
+    public void assertionFailureShowsMultipleErrors() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+
+        ts.onNext("a");
+        ts.onNext("b");
+        ts.onNext("c");
+        ts.onError(new TestException("forced failure"));
+        ts.onError(new TestException("forced failure 2"));
+
+        try {
+            ts.assertValues("1", "2");
+            fail();
+        } catch (AssertionError expected) {
+            assertEquals("Number of items does not match. Provided: 2  Actual: 3.\n" +
+                    "Provided values: [1, 2]\n" +
+                    "Actual values: [a, b, c]\n (0 completions) (+2 errors)",
+                    expected.getMessage()
+            );
+            Throwable ex = expected.getCause();
+            assertEquals(CompositeException.class, ex.getClass());
+            List<Throwable> list = ((CompositeException)ex).getExceptions();
+            assertEquals(2, list.size());
+            assertEquals("forced failure", list.get(0).getMessage());
+            assertEquals("forced failure 2", list.get(1).getMessage());
+        }
+    }
+
+    @Test
+    public void assertionFailureShowsCompletion() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+
+        ts.onNext("a");
+        ts.onNext("b");
+        ts.onNext("c");
+        ts.onCompleted();
+
+        try {
+            ts.assertValues("1", "2");
+            fail();
+        } catch (AssertionError expected) {
+            assertEquals("Number of items does not match. Provided: 2  Actual: 3.\n" +
+                    "Provided values: [1, 2]\n" +
+                    "Actual values: [a, b, c]\n (1 completion)",
+                    expected.getMessage()
+            );
+        }
+    }
+
+    @Test
+    public void assertionFailureShowsMultipleCompletions() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+
+        ts.onNext("a");
+        ts.onNext("b");
+        ts.onNext("c");
+        ts.onCompleted();
+        ts.onCompleted();
+
+        try {
+            ts.assertValues("1", "2");
+            fail();
+        } catch (AssertionError expected) {
+            assertEquals("Number of items does not match. Provided: 2  Actual: 3.\n" +
+                    "Provided values: [1, 2]\n" +
+                    "Actual values: [a, b, c]\n (2 completions)",
+                    expected.getMessage()
+            );
+        }
+    }
+
 }

From c296d521aac828df92fe8933b1b6d4451f030d72 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Tue, 24 May 2016 01:37:46 +0200
Subject: [PATCH 034/263] Add Completable.andThen(Completable), deprecate
 endWith() (#3948)

Closes #3947
---
 src/main/java/rx/Completable.java     | 22 +++++++++++++++++++---
 src/test/java/rx/CompletableTest.java | 24 ++++++++++++------------
 2 files changed, 31 insertions(+), 15 deletions(-)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 8a2a4121d2..4f2eda83df 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -1132,6 +1132,19 @@ public final <T> Single<T> andThen(Single<T> next) {
         requireNonNull(next);
         return next.delaySubscription(toObservable());
     }
+
+    /**
+     * Returns a completable that first runs this Completable
+     * and then the other completable.
+     * <p>
+     * This is an alias for {@link #concatWith(Completable)}.
+     * @param next the other Completable, not null
+     * @return the new Completable instance
+     * @throws NullPointerException if other is null
+     */
+    public final Completable andThen(Completable next) {
+        return concatWith(next);
+    }
     
     /**
      * Concatenates this Completable with another Completable.
@@ -1396,9 +1409,11 @@ public void call(Throwable e) {
      * @param other the other Completable, not null
      * @return the new Completable instance
      * @throws NullPointerException if other is null
+     * @deprecated Use {@link #andThen(rx.Completable)} instead.
      */
+    @Deprecated
     public final Completable endWith(Completable other) {
-        return concatWith(other);
+        return andThen(other);
     }
     
     /**
@@ -1406,10 +1421,11 @@ public final Completable endWith(Completable other) {
      * resumes with the given next Observable.
      * @param next the next Observable to continue
      * @return the new Observable instance
-     * @throws NullPointerException if next is null
+     * @deprecated Use {@link #andThen(rx.Observable)} instead.
      */
+    @Deprecated
     public final <T> Observable<T> endWith(Observable<T> next) {
-        return next.startWith(this.<T>toObservable());
+        return andThen(next);
     }
 
     /**
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 8ee2f747d3..4f7ce67985 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -3530,20 +3530,20 @@ public void startWithFlowableNull() {
     }
 
     @Test(expected = NullPointerException.class)
-    public void endWithCompletableNull() {
-        normal.completable.endWith((Completable)null);
+    public void andThenCompletableNull() {
+        normal.completable.andThen((Completable)null);
     }
 
     @Test(expected = NullPointerException.class)
-    public void endWithFlowableNull() {
-        normal.completable.endWith((Observable<Object>)null);
+    public void andThenFlowableNull() {
+        normal.completable.andThen((Observable<Object>)null);
     }
 
     @Test(timeout = 1000)
-    public void endWithCompletableNormal() {
+    public void andThenCompletableNormal() {
         final AtomicBoolean run = new AtomicBoolean();
         Completable c = normal.completable
-                .endWith(Completable.fromCallable(new Callable<Object>() {
+                .andThen(Completable.fromCallable(new Callable<Object>() {
                     @Override
                     public Object call() throws Exception {
                         run.set(normal.get() == 0);
@@ -3558,8 +3558,8 @@ public Object call() throws Exception {
     }
     
     @Test(timeout = 1000)
-    public void endWithCompletableError() {
-        Completable c = normal.completable.endWith(error.completable);
+    public void andThenCompletableError() {
+        Completable c = normal.completable.andThen(error.completable);
         
         try {
             c.await();
@@ -3571,10 +3571,10 @@ public void endWithCompletableError() {
     }
     
     @Test(timeout = 1000)
-    public void endWithFlowableNormal() {
+    public void andThenFlowableNormal() {
         final AtomicBoolean run = new AtomicBoolean();
         Observable<Object> c = normal.completable
-                .endWith(Observable.fromCallable(new Callable<Object>() {
+                .andThen(Observable.fromCallable(new Callable<Object>() {
                     @Override
                     public Object call() throws Exception {
                         run.set(normal.get() == 0);
@@ -3595,9 +3595,9 @@ public Object call() throws Exception {
     }
     
     @Test(timeout = 1000)
-    public void endWithFlowableError() {
+    public void andThenFlowableError() {
         Observable<Object> c = normal.completable
-                .endWith(Observable.error(new TestException()));
+                .andThen(Observable.error(new TestException()));
         
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
         

From fef520ee5570e3af48fab0fd55f255a39a1ffd70 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 24 May 2016 22:40:35 +0200
Subject: [PATCH 035/263] 1.x: javac- and javadoc-related cleanup in
 components, part 2 (#3951)

* 1.x: javac- and javadoc-related cleanup in components, part 2 final

This PR clears the cast warnings introduced by the need to be JDK 9
compilable.

* 1.x: javac- and javadoc-related cleanup in components, part 2 final
---
 src/main/java/rx/Notification.java            |   7 +-
 src/main/java/rx/Observable.java              |  25 +++--
 src/main/java/rx/Single.java                  | 106 +++++++++++++++++-
 .../operators/BlockingOperatorLatest.java     |   2 +
 .../operators/BlockingOperatorMostRecent.java |   4 +-
 .../operators/BlockingOperatorNext.java       |   2 +
 .../operators/BlockingOperatorToFuture.java   |   1 +
 .../operators/BlockingOperatorToIterator.java |   2 +
 .../operators/BufferUntilSubscriber.java      |   5 +-
 .../internal/operators/CachedObservable.java  |   7 +-
 .../CompletableOnSubscribeConcat.java         |   1 +
 .../CompletableOnSubscribeMerge.java          |   1 +
 .../operators/EmptyObservableHolder.java      |   1 +
 .../operators/NeverObservableHolder.java      |   1 +
 .../internal/operators/NotificationLite.java  |   1 +
 .../rx/internal/operators/OnSubscribeAmb.java |  10 ++
 .../operators/OnSubscribeCombineLatest.java   |   1 +
 .../internal/operators/OnSubscribeDefer.java  |   1 +
 ...ubscribeDelaySubscriptionWithSelector.java |   1 +
 .../operators/OnSubscribeFromCallable.java    |   1 +
 .../operators/OnSubscribeFromIterable.java    |   1 +
 .../internal/operators/OnSubscribeSingle.java |   1 +
 .../operators/OnSubscribeTimerOnce.java       |   2 +-
 .../OnSubscribeTimerPeriodically.java         |   2 +-
 .../rx/internal/operators/OperatorAll.java    |   1 +
 .../rx/internal/operators/OperatorAny.java    |   1 +
 .../operators/OperatorAsObservable.java       |   1 +
 .../OperatorBufferWithSingleObservable.java   |   1 +
 .../OperatorBufferWithStartEndObservable.java |   2 +
 .../rx/internal/operators/OperatorCast.java   |   2 +
 .../internal/operators/OperatorDistinct.java  |   3 +-
 .../OperatorDistinctUntilChanged.java         |   3 +-
 .../internal/operators/OperatorDoOnEach.java  |   1 +
 .../internal/operators/OperatorElementAt.java |   1 +
 .../internal/operators/OperatorGroupBy.java   |   2 +-
 .../operators/OperatorMapNotification.java    |   2 +
 .../internal/operators/OperatorMapPair.java   |   2 +
 .../operators/OperatorMaterialize.java        |   2 +
 .../rx/internal/operators/OperatorMerge.java  |   4 +-
 .../internal/operators/OperatorMulticast.java |   1 +
 .../operators/OperatorOnBackpressureDrop.java |   1 +
 .../OperatorOnBackpressureLatest.java         |   2 +
 .../OperatorOnErrorResumeNextViaFunction.java |   1 +
 .../internal/operators/OperatorPublish.java   |   1 +
 .../rx/internal/operators/OperatorReplay.java |  57 ++++++----
 .../OperatorSampleWithObservable.java         |   2 +-
 .../operators/OperatorSampleWithTime.java     |   2 +-
 .../operators/OperatorSequenceEqual.java      |   1 +
 .../internal/operators/OperatorSerialize.java |   1 +
 .../rx/internal/operators/OperatorSingle.java |   2 +
 .../rx/internal/operators/OperatorSkip.java   |   1 +
 .../internal/operators/OperatorSkipLast.java  |   1 +
 .../operators/OperatorSkipLastTimed.java      |   1 +
 .../internal/operators/OperatorSkipUntil.java |   2 +-
 .../internal/operators/OperatorSkipWhile.java |   8 +-
 .../operators/OperatorSwitchIfEmpty.java      |   1 +
 .../rx/internal/operators/OperatorTake.java   |   1 +
 .../internal/operators/OperatorTakeUntil.java |   2 +
 .../operators/OperatorTakeUntilPredicate.java |   1 +
 .../internal/operators/OperatorTakeWhile.java |   1 +
 .../operators/OperatorThrottleFirst.java      |   1 +
 .../operators/OperatorTimeInterval.java       |   1 +
 .../internal/operators/OperatorTimeout.java   |   1 +
 .../OperatorTimeoutWithSelector.java          |   3 +
 .../internal/operators/OperatorTimestamp.java |   1 +
 .../rx/internal/operators/OperatorToMap.java  |  12 +-
 .../operators/OperatorToMultimap.java         |  18 ++-
 .../operators/OperatorToObservableList.java   |   2 +
 .../operators/OperatorUnsubscribeOn.java      |   1 +
 ...ngleOnSubscribeDelaySubscriptionOther.java |   1 +
 70 files changed, 289 insertions(+), 56 deletions(-)

diff --git a/src/main/java/rx/Notification.java b/src/main/java/rx/Notification.java
index a35cf6e60a..e7099007c5 100644
--- a/src/main/java/rx/Notification.java
+++ b/src/main/java/rx/Notification.java
@@ -17,6 +17,7 @@
 
 /**
  * An object representing a notification sent to an {@link Observable}.
+ * @param <T> the actual value type held by the Notification
  */
 public final class Notification<T> {
 
@@ -29,6 +30,7 @@ public final class Notification<T> {
     /**
      * Creates and returns a {@code Notification} of variety {@code Kind.OnNext}, and assigns it a value.
      *
+     * @param <T> the actual value type held by the Notification
      * @param t
      *          the item to assign to the notification as its value
      * @return an {@code OnNext} variety of {@code Notification}
@@ -40,6 +42,7 @@ public static <T> Notification<T> createOnNext(T t) {
     /**
      * Creates and returns a {@code Notification} of variety {@code Kind.OnError}, and assigns it an exception.
      *
+     * @param <T> the actual value type held by the Notification
      * @param e
      *          the exception to assign to the notification
      * @return an {@code OnError} variety of {@code Notification}
@@ -51,6 +54,7 @@ public static <T> Notification<T> createOnError(Throwable e) {
     /**
      * Creates and returns a {@code Notification} of variety {@code Kind.OnCompleted}.
      *
+     * @param <T> the actual value type held by the Notification
      * @return an {@code OnCompleted} variety of {@code Notification}
      */
     @SuppressWarnings("unchecked")
@@ -61,7 +65,7 @@ public static <T> Notification<T> createOnCompleted() {
     /**
      * Creates and returns a {@code Notification} of variety {@code Kind.OnCompleted}.
      *
-     * @warn param "type" undescribed
+     * @param <T> the actual value type held by the Notification
      * @param type
      * @return an {@code OnCompleted} variety of {@code Notification}
      */
@@ -151,6 +155,7 @@ public boolean isOnNext() {
 
     /**
      * Forwards this notification on to a specified {@link Observer}.
+     * @param observer the target observer to call onXXX methods on based on the kind of this Notification instance
      */
     public void accept(Observer<? super T> observer) {
         if (isOnNext()) {
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 7e0e89a77a..cad9d2d0f7 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -600,7 +600,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *         Observables by means of the given aggregation function
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({ "unchecked", "cast" })
     public static <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Func2<? super T1, ? super T2, ? extends R> combineFunction) {
         return (Observable<R>)combineLatest(Arrays.asList(o1, o2), Functions.fromFunc(combineFunction));
     }
@@ -628,7 +628,7 @@ public static <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o
      *         Observables by means of the given aggregation function
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({ "unchecked", "cast" })
     public static <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> combineFunction) {
         return (Observable<R>)combineLatest(Arrays.asList(o1, o2, o3), Functions.fromFunc(combineFunction));
     }
@@ -658,7 +658,7 @@ public static <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T
      *         Observables by means of the given aggregation function
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({ "unchecked", "cast" })
     public static <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4,
             Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> combineFunction) {
         return (Observable<R>)combineLatest(Arrays.asList(o1, o2, o3, o4), Functions.fromFunc(combineFunction));
@@ -691,7 +691,7 @@ public static <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? exten
      *         Observables by means of the given aggregation function
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({ "unchecked", "cast" })
     public static <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5,
             Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> combineFunction) {
         return (Observable<R>)combineLatest(Arrays.asList(o1, o2, o3, o4, o5), Functions.fromFunc(combineFunction));
@@ -726,7 +726,7 @@ public static <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? e
      *         Observables by means of the given aggregation function
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({ "unchecked", "cast" })
     public static <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6,
             Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> combineFunction) {
         return (Observable<R>)combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6), Functions.fromFunc(combineFunction));
@@ -763,7 +763,7 @@ public static <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable
      *         Observables by means of the given aggregation function
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({ "unchecked", "cast" })
     public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7,
             Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> combineFunction) {
         return (Observable<R>)combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7), Functions.fromFunc(combineFunction));
@@ -802,7 +802,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observ
      *         Observables by means of the given aggregation function
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({ "unchecked", "cast" })
     public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
             Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> combineFunction) {
         return (Observable<R>)combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8), Functions.fromFunc(combineFunction));
@@ -843,7 +843,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Ob
      *         Observables by means of the given aggregation function
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({ "unchecked", "cast" })
     public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
             Observable<? extends T9> o9,
             Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> combineFunction) {
@@ -1311,6 +1311,7 @@ public static <T> Observable<T> error(Throwable exception) {
      * @return an Observable that emits the item from the source {@link Future}
      * @see <a href="http://reactivex.io/documentation/operators/from.html">ReactiveX operators documentation: From</a>
      */
+    @SuppressWarnings("cast")
     public static <T> Observable<T> from(Future<? extends T> future) {
         return (Observable<T>)create(OnSubscribeToObservableFuture.toObservableFuture(future));
     }
@@ -1342,6 +1343,7 @@ public static <T> Observable<T> from(Future<? extends T> future) {
      * @return an Observable that emits the item from the source {@link Future}
      * @see <a href="http://reactivex.io/documentation/operators/from.html">ReactiveX operators documentation: From</a>
      */
+    @SuppressWarnings("cast")
     public static <T> Observable<T> from(Future<? extends T> future, long timeout, TimeUnit unit) {
         return (Observable<T>)create(OnSubscribeToObservableFuture.toObservableFuture(future, timeout, unit));
     }
@@ -1372,6 +1374,7 @@ public static <T> Observable<T> from(Future<? extends T> future, long timeout, T
      */
     public static <T> Observable<T> from(Future<? extends T> future, Scheduler scheduler) {
         // TODO in a future revision the Scheduler will become important because we'll start polling instead of blocking on the Future
+        @SuppressWarnings("cast")
         Observable<T> o = (Observable<T>)create(OnSubscribeToObservableFuture.toObservableFuture(future));
         return o.subscribeOn(scheduler);
     }
@@ -5742,6 +5745,7 @@ public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterab
      *         Observable
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
      */
+    @SuppressWarnings("cast")
     public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterable<? extends U>> collectionSelector,
             Func2<? super T, ? super U, ? extends R> resultSelector) {
         return (Observable<R>)flatMap(OperatorMapPair.convertSelector(collectionSelector), resultSelector);
@@ -5777,6 +5781,7 @@ public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Ite
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
+    @SuppressWarnings("cast")
     @Beta
     public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterable<? extends U>> collectionSelector,
             Func2<? super T, ? super U, ? extends R> resultSelector, int maxConcurrent) {
@@ -6554,6 +6559,7 @@ public final Observable<T> onErrorResumeNext(final Func1<Throwable, ? extends Ob
      * @return the original Observable, with appropriately modified behavior
      * @see <a href="http://reactivex.io/documentation/operators/catch.html">ReactiveX operators documentation: Catch</a>
      */
+    @SuppressWarnings("cast")
     public final Observable<T> onErrorResumeNext(final Observable<? extends T> resumeSequence) {
         return lift((Operator<T, T>)OperatorOnErrorResumeNextViaFunction.withOther(resumeSequence));
     }
@@ -6584,6 +6590,7 @@ public final Observable<T> onErrorResumeNext(final Observable<? extends T> resum
      * @return the original Observable with appropriately modified behavior
      * @see <a href="http://reactivex.io/documentation/operators/catch.html">ReactiveX operators documentation: Catch</a>
      */
+    @SuppressWarnings("cast")
     public final Observable<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunction) {
         return lift((Operator<T, T>)OperatorOnErrorResumeNextViaFunction.withSingle(resumeFunction));
     }
@@ -6620,6 +6627,7 @@ public final Observable<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFun
      * @return the original Observable, with appropriately modified behavior
      * @see <a href="http://reactivex.io/documentation/operators/catch.html">ReactiveX operators documentation: Catch</a>
      */
+    @SuppressWarnings("cast")
     public final Observable<T> onExceptionResumeNext(final Observable<? extends T> resumeSequence) {
         return lift((Operator<T, T>)OperatorOnErrorResumeNextViaFunction.withException(resumeSequence));
     }
@@ -10327,6 +10335,7 @@ public final <T2, R> Observable<R> zipWith(Iterable<? extends T2> other, Func2<?
      *         and emits the results of {@code zipFunction} applied to these pairs
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
      */
+    @SuppressWarnings("cast")
     public final <T2, R> Observable<R> zipWith(Observable<? extends T2> other, Func2<? super T, ? super T2, ? extends R> zipFunction) {
         return (Observable<R>)zip(this, other, zipFunction);
     }
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 5bbe3f2e22..97c55c0719 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -204,6 +204,7 @@ public void call(Subscriber<? super R> o) {
      * <dd>{@code compose} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the value type of the single returned by the transformer function
      * @param transformer
      *            implements the function that transforms the source Single
      * @return the source Single, transformed by the transformer function
@@ -218,6 +219,8 @@ public <R> Single<R> compose(Transformer<? super T, ? extends R> transformer) {
      * Transformer function used by {@link #compose}.
      * 
      * @warn more complete description needed
+     * @param <T> the source Single's value type
+     * @param <R> the transformed Single's value type
      */
     public interface Transformer<T, R> extends Func1<Single<T>, Single<R>> {
         // cover for generics insanity
@@ -248,6 +251,7 @@ private static <T> Observable<T> asObservable(Single<T> t) {
      * @return a Single that emits an Observable that emits the same item as the source Single
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
+    @SuppressWarnings("unused")
     private Single<Observable<T>> nest() {
         return Single.just(asObservable(this));
     }
@@ -265,7 +269,8 @@ private Single<Observable<T>> nest() {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     *
+     * 
+     * @param <T> the common value type
      * @param t1
      *            an Single to be concatenated
      * @param t2
@@ -286,6 +291,7 @@ public static <T> Observable<T> concat(Single<? extends T> t1, Single<? extends
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common value type
      * @param t1
      *            a Single to be concatenated
      * @param t2
@@ -308,6 +314,7 @@ public static <T> Observable<T> concat(Single<? extends T> t1, Single<? extends
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common value type
      * @param t1
      *            a Single to be concatenated
      * @param t2
@@ -332,6 +339,7 @@ public static <T> Observable<T> concat(Single<? extends T> t1, Single<? extends
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common value type
      * @param t1
      *            a Single to be concatenated
      * @param t2
@@ -358,6 +366,7 @@ public static <T> Observable<T> concat(Single<? extends T> t1, Single<? extends
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common value type
      * @param t1
      *            a Single to be concatenated
      * @param t2
@@ -386,6 +395,7 @@ public static <T> Observable<T> concat(Single<? extends T> t1, Single<? extends
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common value type
      * @param t1
      *            a Single to be concatenated
      * @param t2
@@ -416,6 +426,7 @@ public static <T> Observable<T> concat(Single<? extends T> t1, Single<? extends
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common value type
      * @param t1
      *            a Single to be concatenated
      * @param t2
@@ -448,6 +459,7 @@ public static <T> Observable<T> concat(Single<? extends T> t1, Single<? extends
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common value type
      * @param t1
      *            a Single to be concatenated
      * @param t2
@@ -525,6 +537,7 @@ public void call(SingleSubscriber<? super T> te) {
      * @return a {@code Single} that emits the item from the source {@link Future}
      * @see <a href="http://reactivex.io/documentation/operators/from.html">ReactiveX operators documentation: From</a>
      */
+    @SuppressWarnings("cast")
     public static <T> Single<T> from(Future<? extends T> future) {
         return new Single<T>((Observable.OnSubscribe<T>)OnSubscribeToObservableFuture.toObservableFuture(future));
     }
@@ -556,6 +569,7 @@ public static <T> Single<T> from(Future<? extends T> future) {
      * @return a {@code Single} that emits the item from the source {@link Future}
      * @see <a href="http://reactivex.io/documentation/operators/from.html">ReactiveX operators documentation: From</a>
      */
+    @SuppressWarnings("cast")
     public static <T> Single<T> from(Future<? extends T> future, long timeout, TimeUnit unit) {
         return new Single<T>((Observable.OnSubscribe<T>)OnSubscribeToObservableFuture.toObservableFuture(future, timeout, unit));
     }
@@ -584,6 +598,7 @@ public static <T> Single<T> from(Future<? extends T> future, long timeout, TimeU
      * @return a {@code Single} that emits the item from the source {@link Future}
      * @see <a href="http://reactivex.io/documentation/operators/from.html">ReactiveX operators documentation: From</a>
      */
+    @SuppressWarnings("cast")
     public static <T> Single<T> from(Future<? extends T> future, Scheduler scheduler) {
         return new Single<T>((Observable.OnSubscribe<T>)OnSubscribeToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler);
     }
@@ -706,6 +721,7 @@ public void onError(Throwable error) {
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common value type
      * @param t1
      *            a Single to be merged
      * @param t2
@@ -729,6 +745,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common value type
      * @param t1
      *            a Single to be merged
      * @param t2
@@ -754,6 +771,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common value type
      * @param t1
      *            a Single to be merged
      * @param t2
@@ -781,6 +799,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common value type
      * @param t1
      *            a Single to be merged
      * @param t2
@@ -810,6 +829,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common value type
      * @param t1
      *            a Single to be merged
      * @param t2
@@ -841,6 +861,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common value type
      * @param t1
      *            a Single to be merged
      * @param t2
@@ -874,6 +895,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common value type
      * @param t1
      *            a Single to be merged
      * @param t2
@@ -909,6 +931,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common value type
      * @param t1
      *            a Single to be merged
      * @param t2
@@ -944,6 +967,9 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the first source Single's value type
+     * @param <T2> the second source Single's value type
+     * @param <R> the result value type
      * @param s1
      *            the first source Single
      * @param s2
@@ -954,6 +980,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * @return a Single that emits the zipped results
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
      */
+    @SuppressWarnings("unchecked")
     public static <T1, T2, R> Single<R> zip(Single<? extends T1> s1, Single<? extends T2> s2, final Func2<? super T1, ? super T2, ? extends R> zipFunction) {
         return SingleOperatorZip.zip(new Single[] {s1, s2}, new FuncN<R>() {
             @Override
@@ -973,6 +1000,10 @@ public R call(Object... args) {
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the first source Single's value type
+     * @param <T2> the second source Single's value type
+     * @param <T3> the third source Single's value type
+     * @param <R> the result value type
      * @param s1
      *            the first source Single
      * @param s2
@@ -985,6 +1016,7 @@ public R call(Object... args) {
      * @return a Single that emits the zipped results
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
      */
+    @SuppressWarnings("unchecked")
     public static <T1, T2, T3, R> Single<R> zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, final Func3<? super T1, ? super T2, ? super T3, ? extends R> zipFunction) {
         return SingleOperatorZip.zip(new Single[] {s1, s2, s3}, new FuncN<R>() {
             @Override
@@ -1004,6 +1036,11 @@ public R call(Object... args) {
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the first source Single's value type
+     * @param <T2> the second source Single's value type
+     * @param <T3> the third source Single's value type
+     * @param <T4> the fourth source Single's value type
+     * @param <R> the result value type
      * @param s1
      *            the first source Single
      * @param s2
@@ -1018,6 +1055,7 @@ public R call(Object... args) {
      * @return a Single that emits the zipped results
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
      */
+    @SuppressWarnings("unchecked")
     public static <T1, T2, T3, T4, R> Single<R> zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, final Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> zipFunction) {
         return SingleOperatorZip.zip(new Single[] {s1, s2, s3, s4}, new FuncN<R>() {
             @Override
@@ -1037,6 +1075,12 @@ public R call(Object... args) {
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the first source Single's value type
+     * @param <T2> the second source Single's value type
+     * @param <T3> the third source Single's value type
+     * @param <T4> the fourth source Single's value type
+     * @param <T5> the fifth source Single's value type
+     * @param <R> the result value type
      * @param s1
      *            the first source Single
      * @param s2
@@ -1053,6 +1097,7 @@ public R call(Object... args) {
      * @return a Single that emits the zipped results
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
      */
+    @SuppressWarnings("unchecked")
     public static <T1, T2, T3, T4, T5, R> Single<R> zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, final Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> zipFunction) {
         return SingleOperatorZip.zip(new Single[] {s1, s2, s3, s4, s5}, new FuncN<R>() {
             @Override
@@ -1072,6 +1117,13 @@ public R call(Object... args) {
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the first source Single's value type
+     * @param <T2> the second source Single's value type
+     * @param <T3> the third source Single's value type
+     * @param <T4> the fourth source Single's value type
+     * @param <T5> the fifth source Single's value type
+     * @param <T6> the sixth source Single's value type
+     * @param <R> the result value type
      * @param s1
      *            the first source Single
      * @param s2
@@ -1090,6 +1142,7 @@ public R call(Object... args) {
      * @return a Single that emits the zipped results
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
      */
+    @SuppressWarnings("unchecked")
     public static <T1, T2, T3, T4, T5, T6, R> Single<R> zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6,
                                                             final Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> zipFunction) {
         return SingleOperatorZip.zip(new Single[] {s1, s2, s3, s4, s5, s6}, new FuncN<R>() {
@@ -1110,6 +1163,14 @@ public R call(Object... args) {
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the first source Single's value type
+     * @param <T2> the second source Single's value type
+     * @param <T3> the third source Single's value type
+     * @param <T4> the fourth source Single's value type
+     * @param <T5> the fifth source Single's value type
+     * @param <T6> the sixth source Single's value type
+     * @param <T7> the seventh source Single's value type
+     * @param <R> the result value type
      * @param s1
      *            the first source Single
      * @param s2
@@ -1130,6 +1191,7 @@ public R call(Object... args) {
      * @return a Single that emits the zipped results
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
      */
+    @SuppressWarnings("unchecked")
     public static <T1, T2, T3, T4, T5, T6, T7, R> Single<R> zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6, Single<? extends T7> s7,
                                                                 final Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> zipFunction) {
         return SingleOperatorZip.zip(new Single[] {s1, s2, s3, s4, s5, s6, s7}, new FuncN<R>() {
@@ -1150,6 +1212,15 @@ public R call(Object... args) {
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the first source Single's value type
+     * @param <T2> the second source Single's value type
+     * @param <T3> the third source Single's value type
+     * @param <T4> the fourth source Single's value type
+     * @param <T5> the fifth source Single's value type
+     * @param <T6> the sixth source Single's value type
+     * @param <T7> the seventh source Single's value type
+     * @param <T8> the eigth source Single's value type
+     * @param <R> the result value type
      * @param s1
      *            the first source Single
      * @param s2
@@ -1172,6 +1243,7 @@ public R call(Object... args) {
      * @return a Single that emits the zipped results
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
      */
+    @SuppressWarnings("unchecked")
     public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Single<R> zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6, Single<? extends T7> s7, Single<? extends T8> s8,
                                                                     final Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> zipFunction) {
         return SingleOperatorZip.zip(new Single[] {s1, s2, s3, s4, s5, s6, s7, s8}, new FuncN<R>() {
@@ -1192,6 +1264,16 @@ public R call(Object... args) {
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the first source Single's value type
+     * @param <T2> the second source Single's value type
+     * @param <T3> the third source Single's value type
+     * @param <T4> the fourth source Single's value type
+     * @param <T5> the fifth source Single's value type
+     * @param <T6> the sixth source Single's value type
+     * @param <T7> the seventh source Single's value type
+     * @param <T8> the eigth source Single's value type
+     * @param <T9> the ninth source Single's value type
+     * @param <R> the result value type
      * @param s1
      *            the first source Single
      * @param s2
@@ -1216,6 +1298,7 @@ public R call(Object... args) {
      * @return a Single that emits the zipped results
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
      */
+    @SuppressWarnings("unchecked")
     public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Single<R> zip(Single<? extends T1> s1, Single<? extends T2> s2, Single<? extends T3> s3, Single<? extends T4> s4, Single<? extends T5> s5, Single<? extends T6> s6, Single<? extends T7> s7, Single<? extends T8> s8,
                                                                         Single<? extends T9> s9, final Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> zipFunction) {
         return SingleOperatorZip.zip(new Single[] {s1, s2, s3, s4, s5, s6, s7, s8, s9}, new FuncN<R>() {
@@ -1238,6 +1321,7 @@ public R call(Object... args) {
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <R> the result value type
      * @param singles
      *            an Iterable of source Singles. Should not be empty because {@link Single} either emits result or error.
      *            {@link java.util.NoSuchElementException} will be emit as error if Iterable will be empty.
@@ -1247,7 +1331,9 @@ public R call(Object... args) {
      * @return a Single that emits the zipped results
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
      */
+    @SuppressWarnings("unchecked")
     public static <R> Single<R> zip(Iterable<? extends Single<?>> singles, FuncN<? extends R> zipFunction) {
+        @SuppressWarnings("rawtypes")
         Single[] iterableToArray = iterableToArray(singles);
         return SingleOperatorZip.zip(iterableToArray, zipFunction);
     }
@@ -1282,6 +1368,7 @@ public final Observable<T> concatWith(Single<? extends T> t1) {
      * <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the result value type
      * @param func
      *            a function that, when applied to the item emitted by the source Single, returns a Single
      * @return the Single returned from {@code func} when applied to the item emitted by the source Single
@@ -1304,6 +1391,7 @@ public final <R> Single<R> flatMap(final Func1<? super T, ? extends Single<? ext
      * <dd>{@code flatMapObservable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the result value type
      * @param func
      *            a function that, when applied to the item emitted by the source Single, returns an
      *            Observable
@@ -1324,6 +1412,7 @@ public final <R> Observable<R> flatMapObservable(Func1<? super T, ? extends Obse
      * <dd>{@code map} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <R> the result value type
      * @param func
      *            a function to apply to the item emitted by the Single
      * @return a Single that emits the item from the source Single, transformed by the specified function
@@ -1407,6 +1496,7 @@ public final Single<T> observeOn(Scheduler scheduler) {
      * @return the original Single with appropriately modified behavior
      * @see <a href="http://reactivex.io/documentation/operators/catch.html">ReactiveX operators documentation: Catch</a>
      */
+    @SuppressWarnings("cast")
     public final Single<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunction) {
         return lift((Operator<T, T>)OperatorOnErrorResumeNextViaFunction.withSingle(resumeFunction));
     }
@@ -1613,6 +1703,7 @@ public final void onNext(T args) {
      * 
      * @param subscriber
      *            the Subscriber that will handle the emission or notification from the Single
+     * @return the subscription that allows unsubscribing
      */
     public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
         try {
@@ -2116,8 +2207,7 @@ public final Observable<T> toObservable() {
      *
      * @return a {@link Completable} that calls {@code onCompleted} on it's subscriber when the source {@link Single}
      *         calls {@code onSuccess}.
-     * @see <a href="http://reactivex.io/documentation/completable.html">ReactiveX documentation:
-     *      Completable</a>.
+     * @see <a href="http://reactivex.io/documentation/completable.html">ReactiveX documentation: Completable</a>
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical
      *        with the release number).
      */
@@ -2265,6 +2355,7 @@ public final BlockingSingle<T> toBlocking() {
      *         and emits the results of {@code zipFunction} applied to these pairs
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
      */
+    @SuppressWarnings("cast")
     public final <T2, R> Single<R> zipWith(Single<? extends T2> other, Func2<? super T, ? super T2, ? extends R> zipFunction) {
         return (Single<R>)zip(this, other, zipFunction);
     }
@@ -2658,6 +2749,8 @@ public final Single<T> retryWhen(final Func1<Observable<? extends Throwable>, ?
      *  <dd>{@code using} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the value type of the generated source
+     * @param <Resource> the type of the per-subscriber resource
      * @param resourceFactory
      *            the factory function to create a resource object that depends on the Single
      * @param singleFactory
@@ -2670,9 +2763,9 @@ public final Single<T> retryWhen(final Func1<Observable<? extends Throwable>, ?
     @Experimental
     public static <T, Resource> Single<T> using(
             final Func0<Resource> resourceFactory,
-            final Func1<? super Resource, ? extends Single<? extends T>> observableFactory,
+            final Func1<? super Resource, ? extends Single<? extends T>> singleFactory,
             final Action1<? super Resource> disposeAction) {
-        return using(resourceFactory, observableFactory, disposeAction, false);
+        return using(resourceFactory, singleFactory, disposeAction, false);
     }
     
     /**
@@ -2688,7 +2781,8 @@ public static <T, Resource> Single<T> using(
      *  <dd>{@code using} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
-     * @warn "Backpressure Support" section missing from javadoc
+     * @param <T> the value type of the generated source
+     * @param <Resource> the type of the per-subscriber resource
      * @param resourceFactory
      *            the factory function to create a resource object that depends on the Single
      * @param singleFactory
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
index d744da2c02..2a75eceb43 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
@@ -39,6 +39,7 @@ private BlockingOperatorLatest() {
      * Returns an {@code Iterable} that blocks until or unless the {@code Observable} emits an item that has not
      * been returned by the {@code Iterable}, then returns that item
      *
+     * @param <T> the value type
      * @param source
      *            the source {@code Observable}
      * @return an {@code Iterable} that blocks until or unless the {@code Observable} emits an item that has not
@@ -46,6 +47,7 @@ private BlockingOperatorLatest() {
      */
     public static <T> Iterable<T> latest(final Observable<? extends T> source) {
         return new Iterable<T>() {
+            @SuppressWarnings("unchecked")
             @Override
             public Iterator<T> iterator() {
                 LatestObserverIterator<T> lio = new LatestObserverIterator<T>();
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java b/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
index 4cd424be29..3a55cf0cb7 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
@@ -35,6 +35,7 @@ private BlockingOperatorMostRecent() {
     /**
      * Returns an {@code Iterable} that always returns the item most recently emitted by the {@code Observable}.
      *
+     * @param <T> the value type
      * @param source
      *            the source {@code Observable}
      * @param initialValue
@@ -45,6 +46,7 @@ private BlockingOperatorMostRecent() {
      */
     public static <T> Iterable<T> mostRecent(final Observable<? extends T> source, final T initialValue) {
         return new Iterable<T>() {
+            @SuppressWarnings("unchecked")
             @Override
             public Iterator<T> iterator() {
                 MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue);
@@ -86,7 +88,7 @@ public void onNext(T args) {
         /**
          * The {@link Iterator} return is not thread safe. In other words don't call {@link Iterator#hasNext()} in one
          * thread expect {@link Iterator#next()} called from a different thread to work.
-         * @return
+         * @return the Iterator instance
          */
         public Iterator<T> getIterable() {
             return new Iterator<T>() {
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorNext.java b/src/main/java/rx/internal/operators/BlockingOperatorNext.java
index fc6a41487b..94820b4acf 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorNext.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorNext.java
@@ -40,6 +40,7 @@ private BlockingOperatorNext() {
      * Returns an {@code Iterable} that blocks until the {@code Observable} emits another item, then returns
      * that item.
      *
+     * @param <T> the value type
      * @param items
      *            the {@code Observable} to observe
      * @return an {@code Iterable} that behaves like a blocking version of {@code items}
@@ -90,6 +91,7 @@ public boolean hasNext() {
             return moveToNext();
         }
 
+        @SuppressWarnings("unchecked")
         private boolean moveToNext() {
             try {
                 if (!started) {
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java b/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
index daeee2e770..20a2377472 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
@@ -54,6 +54,7 @@ public static <T> Future<T> toFuture(Observable<? extends T> that) {
         final AtomicReference<T> value = new AtomicReference<T>();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
 
+        @SuppressWarnings("unchecked")
         final Subscription s = ((Observable<T>)that).single().subscribe(new Subscriber<T>() {
 
             @Override
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java b/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java
index 6f0f9b2616..60de1157c9 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java
@@ -44,8 +44,10 @@ private BlockingOperatorToIterator() {
      * 
      * @param <T>
      *            the type of source.
+     * @param source the source Observable
      * @return the iterator that could be used to iterate over the elements of the observable.
      */
+    @SuppressWarnings("unchecked")
     public static <T> Iterator<T> toIterator(Observable<? extends T> source) {
         SubscriberIterator<T> subscriber = new SubscriberIterator<T>();
 
diff --git a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
index 0ba5bfab61..2fcf60cf45 100644
--- a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
+++ b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
@@ -50,8 +50,9 @@
 public final class BufferUntilSubscriber<T> extends Subject<T, T> {
 
     /**
-     * @warn create() undescribed
-     * @return
+     * Creates a default, unbounded buffering Subject instance.
+     * @param <T> the value type
+     * @return the instance
      */
     public static <T> BufferUntilSubscriber<T> create() {
         State<T> state = new State<T>();
diff --git a/src/main/java/rx/internal/operators/CachedObservable.java b/src/main/java/rx/internal/operators/CachedObservable.java
index 6d9e7b6da6..c9b6c47cda 100644
--- a/src/main/java/rx/internal/operators/CachedObservable.java
+++ b/src/main/java/rx/internal/operators/CachedObservable.java
@@ -35,15 +35,18 @@ public final class CachedObservable<T> extends Observable<T> {
 
     /**
      * Creates a cached Observable with a default capacity hint of 16.
+     * @param <T> the value type
      * @param source the source Observable to cache
      * @return the CachedObservable instance
      */
+    @SuppressWarnings("cast")
     public static <T> CachedObservable<T> from(Observable<? extends T> source) {
         return (CachedObservable<T>)from(source, 16);
     }
     
     /**
      * Creates a cached Observable with the given capacity hint.
+     * @param <T> the value type
      * @param source the source Observable to cache
      * @param capacityHint the hint for the internal buffer size
      * @return the CachedObservable instance
@@ -308,8 +311,8 @@ public void request(long n) {
         }
         /**
          * Updates the request count to reflect values have been produced.
-         * @param n
-         * @return
+         * @param n the produced item count, positive, not validated
+         * @return the latest request amount after subtracting n
          */
         public long produced(long n) {
             return addAndGet(-n);
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
index 8257c158a7..85d2509264 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
@@ -29,6 +29,7 @@ public final class CompletableOnSubscribeConcat implements CompletableOnSubscrib
     final Observable<Completable> sources;
     final int prefetch;
     
+    @SuppressWarnings("unchecked")
     public CompletableOnSubscribeConcat(Observable<? extends Completable> sources, int prefetch) {
         this.sources = (Observable<Completable>)sources;
         this.prefetch = prefetch;
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
index 7c3fff300c..651ae49bc1 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
@@ -32,6 +32,7 @@ public final class CompletableOnSubscribeMerge implements CompletableOnSubscribe
     final int maxConcurrency;
     final boolean delayErrors;
     
+    @SuppressWarnings("unchecked")
     public CompletableOnSubscribeMerge(Observable<? extends Completable> source, int maxConcurrency, boolean delayErrors) {
         this.source = (Observable<Completable>)source;
         this.maxConcurrency = maxConcurrency;
diff --git a/src/main/java/rx/internal/operators/EmptyObservableHolder.java b/src/main/java/rx/internal/operators/EmptyObservableHolder.java
index 20091ca211..00f4e16f68 100644
--- a/src/main/java/rx/internal/operators/EmptyObservableHolder.java
+++ b/src/main/java/rx/internal/operators/EmptyObservableHolder.java
@@ -29,6 +29,7 @@ public enum EmptyObservableHolder implements OnSubscribe<Object> {
     
     /**
      * Returns a type-corrected singleton instance of the empty Observable.
+     * @param <T> the value type
      * @return a type-corrected singleton instance of the empty Observable.
      */
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/operators/NeverObservableHolder.java b/src/main/java/rx/internal/operators/NeverObservableHolder.java
index 451f31c67b..5114772872 100644
--- a/src/main/java/rx/internal/operators/NeverObservableHolder.java
+++ b/src/main/java/rx/internal/operators/NeverObservableHolder.java
@@ -29,6 +29,7 @@ public enum NeverObservableHolder implements OnSubscribe<Object> {
     
     /**
      * Returns a type-corrected singleton instance of the never Observable.
+     * @param <T> the value type
      * @return a type-corrected singleton instance of the never Observable.
      */
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/operators/NotificationLite.java b/src/main/java/rx/internal/operators/NotificationLite.java
index 0293beab95..223d5299cd 100644
--- a/src/main/java/rx/internal/operators/NotificationLite.java
+++ b/src/main/java/rx/internal/operators/NotificationLite.java
@@ -44,6 +44,7 @@ private NotificationLite() {
     /**
      * Gets the {@code NotificationLite} singleton.
      *
+     * @param <T> the value type
      * @return the sole {@code NotificationLite} object
      */
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/operators/OnSubscribeAmb.java b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
index c5d611375d..3b39357b07 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeAmb.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
@@ -30,12 +30,14 @@
 
 /**
  * Given multiple {@link Observable}s, propagates the one that first emits an item.
+ * @param <T> the value type
  */
 public final class OnSubscribeAmb<T> implements OnSubscribe<T>{
 
     /**
      * Given two {@link Observable}s, propagates the one that first emits an item.
      *
+     * @param <T> the common value base type
      * @param o1
      *          the first {@code Observable}
      * @param o2
@@ -53,6 +55,7 @@ public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? ex
     /**
      * Given three {@link Observable}s, propagates the one that first emits an item.
      *
+     * @param <T> the common value base type
      * @param o1
      *          the first {@code Observable}
      * @param o2
@@ -73,6 +76,7 @@ public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? ex
     /**
      * Given four {@link Observable}s, propagates the one that first emits an item.
      *
+     * @param <T> the common value base type
      * @param o1
      *          the first {@code Observable}
      * @param o2
@@ -96,6 +100,7 @@ public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? ex
     /**
      * Given five {@link Observable}s, propagates the one that first emits an item.
      *
+     * @param <T> the common value base type
      * @param o1
      *          the first {@code Observable}
      * @param o2
@@ -122,6 +127,7 @@ public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? ex
     /**
      * Given six {@link Observable}s, propagates the one that first emits an item.
      *
+     * @param <T> the common value base type
      * @param o1
      *          the first {@code Observable}
      * @param o2
@@ -151,6 +157,7 @@ public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? ex
     /**
      * Given seven {@link Observable}s, propagates the one that first emits an item.
      *
+     * @param <T> the common value base type
      * @param o1
      *          the first {@code Observable}
      * @param o2
@@ -183,6 +190,7 @@ public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? ex
     /**
      * Given eight {@link Observable}s, propagates the one that first emits an item.
      *
+     * @param <T> the common value base type
      * @param o1
      *          the first {@code Observable}
      * @param o2
@@ -218,6 +226,7 @@ public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? ex
     /**
      * Given nine {@link Observable}s, propagates the one that first emits an item.
      *
+     * @param <T> the common value base type
      * @param o1
      *          the first {@code Observable}
      * @param o2
@@ -256,6 +265,7 @@ public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? ex
     /**
      * Given a set of {@link Observable}s, propagates the one that first emits an item.
      *
+     * @param <T> the common value base type
      * @param sources
      *          an {@code Iterable} of {@code Observable}s
      * @return an {@code Observable} that mirrors the one of the {@code Observable}s in {@code sources} that was
diff --git a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
index f254331913..10b4b582cd 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
@@ -127,6 +127,7 @@ public LatestCoordinator(Subscriber<? super R> actual,
             this.error = new AtomicReference<Throwable>();
         }
         
+        @SuppressWarnings("unchecked")
         public void subscribe(Observable<? extends T>[] sources) {
             Subscriber<T>[] as = subscribers;
             int len = as.length;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDefer.java b/src/main/java/rx/internal/operators/OnSubscribeDefer.java
index 34a060df41..c3dff6914b 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDefer.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDefer.java
@@ -31,6 +31,7 @@
  * Pass defer an Observable factory function (a function that generates Observables), and defer will
  * return an Observable that will call this function to generate its Observable sequence afresh
  * each time a new Observer subscribes.
+ * @param <T> the value type
  */
 public final class OnSubscribeDefer<T> implements OnSubscribe<T> {
     final Func0<? extends Observable<? extends T>> observableFactory;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionWithSelector.java b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionWithSelector.java
index 8c57c44f62..6b3fb02d62 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionWithSelector.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionWithSelector.java
@@ -26,6 +26,7 @@
  * 
  * @param <T>
  *            the value type
+ * @param <U> the value type of the Observable triggering the delayed subscription
  */
 public final class OnSubscribeDelaySubscriptionWithSelector<T, U> implements OnSubscribe<T> {
     final Observable<? extends T> source;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java b/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java
index 02e4d4cb93..2a81e9f1f0 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java
@@ -29,6 +29,7 @@
  * <p>
  * Pass {@code fromCallable} a function, and {@code fromCallable} will call this function to emit result of invocation
  * afresh each time a new Observer subscribes.
+ * @param <T> the value type emitted
  */
 public final class OnSubscribeFromCallable<T> implements Observable.OnSubscribe<T> {
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java b/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
index 8df3d1c0d8..9ee3104f95 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
@@ -29,6 +29,7 @@
  * <p>
  * You can convert any object that supports the Iterable interface into an Observable that emits each item in
  * the object, with the {@code toObservable} operation.
+ * @param <T> the value type of the items
  */
 public final class OnSubscribeFromIterable<T> implements OnSubscribe<T> {
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeSingle.java b/src/main/java/rx/internal/operators/OnSubscribeSingle.java
index 27e976e30c..7bfdcca511 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeSingle.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeSingle.java
@@ -25,6 +25,7 @@
 /**
  * Allows conversion of an Observable to a Single ensuring that exactly one item is emitted - no more and no less.
  * Also forwards errors as appropriate.
+ * @param <T> the value type
  */
 public class OnSubscribeSingle<T> implements Single.OnSubscribe<T> {
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java b/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java
index 2b618ac21f..4d2a7389b2 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java
@@ -25,7 +25,7 @@
 
 /**
  * Timer that emits a single 0L and completes after the specified time.
- * @see <a href='http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.timer.aspx'>MSDN Observable.Timer</a>
+ * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.timer.aspx">MSDN Observable.Timer</a>
  */
 public final class OnSubscribeTimerOnce implements OnSubscribe<Long> {
     final long time;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java b/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java
index bbf14f34a7..dedf978f96 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java
@@ -25,7 +25,7 @@
 
 /**
  * Emit 0L after the initial period and ever increasing number after each period.
- * @see <a href='http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.timer.aspx'>MSDN Observable.Timer</a>
+ * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.timer.aspx">MSDN Observable.Timer</a>
  */
 public final class OnSubscribeTimerPeriodically implements OnSubscribe<Long> {
     final long initialDelay;
diff --git a/src/main/java/rx/internal/operators/OperatorAll.java b/src/main/java/rx/internal/operators/OperatorAll.java
index 91160c048e..48053ed710 100644
--- a/src/main/java/rx/internal/operators/OperatorAll.java
+++ b/src/main/java/rx/internal/operators/OperatorAll.java
@@ -26,6 +26,7 @@
  * Observable satisfy a condition.
  * <p>
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/all.png" alt="">
+ * @param <T> the value type
  */
 public final class OperatorAll<T> implements Operator<Boolean, T> {
     final Func1<? super T, Boolean> predicate;
diff --git a/src/main/java/rx/internal/operators/OperatorAny.java b/src/main/java/rx/internal/operators/OperatorAny.java
index 50934a6513..9369b62b39 100644
--- a/src/main/java/rx/internal/operators/OperatorAny.java
+++ b/src/main/java/rx/internal/operators/OperatorAny.java
@@ -25,6 +25,7 @@
 /**
  * Returns an {@link Observable} that emits <code>true</code> if any element of
  * an observable sequence satisfies a condition, otherwise <code>false</code>.
+ * @param <T> the input value type
  */
 public final class OperatorAny<T> implements Operator<Boolean, T> {
     final Func1<? super T, Boolean> predicate;
diff --git a/src/main/java/rx/internal/operators/OperatorAsObservable.java b/src/main/java/rx/internal/operators/OperatorAsObservable.java
index 8efa3e8f6f..9cb9d8ac56 100644
--- a/src/main/java/rx/internal/operators/OperatorAsObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorAsObservable.java
@@ -31,6 +31,7 @@ private static final class Holder {
         static final OperatorAsObservable<Object> INSTANCE = new OperatorAsObservable<Object>();
     }
     /**
+     * @param <T> the value type
      * @return a singleton instance of this stateless operator.
      */
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java b/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
index 187bc0494a..b5f9a68493 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
@@ -41,6 +41,7 @@
  * </p>
  * 
  * @param <T> the buffered value type
+ * @param <TClosing> the value type of the Observable signaling the end of each buffer
  */
 
 public final class OperatorBufferWithSingleObservable<T, TClosing> implements Operator<List<T>, T> {
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java b/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
index 328f401a2e..9938bc4534 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
@@ -45,6 +45,8 @@
  * </p>
  * 
  * @param <T> the buffered value type
+ * @param <TOpening> the value type of the Observable opening buffers
+ * @param <TClosing> the value type of the Observable closing buffers
  */
 
 public final class OperatorBufferWithStartEndObservable<T, TOpening, TClosing> implements Operator<List<T>, T> {
diff --git a/src/main/java/rx/internal/operators/OperatorCast.java b/src/main/java/rx/internal/operators/OperatorCast.java
index 02099f31ad..be14ef91e8 100644
--- a/src/main/java/rx/internal/operators/OperatorCast.java
+++ b/src/main/java/rx/internal/operators/OperatorCast.java
@@ -22,6 +22,8 @@
 
 /**
  * Converts the elements of an observable sequence to the specified type.
+ * @param <T> the input value type
+ * @param <R> the output value type
  */
 public class OperatorCast<T, R> implements Operator<R, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorDistinct.java b/src/main/java/rx/internal/operators/OperatorDistinct.java
index b71738b7c1..a581b1b1e0 100644
--- a/src/main/java/rx/internal/operators/OperatorDistinct.java
+++ b/src/main/java/rx/internal/operators/OperatorDistinct.java
@@ -40,10 +40,11 @@ private static class Holder {
      * Returns a singleton instance of OperatorDistinct that was built using 
      * the identity function for comparison (<code>new OperatorDistinct(UtilityFunctions.identity())</code>).
      * 
+     * @param <T> the value type
      * @return Operator that emits distinct values only (regardless of order) using the identity function for comparison 
      */
     @SuppressWarnings("unchecked")
-    public static <T> OperatorDistinct<T,T> instance() {
+    public static <T> OperatorDistinct<T, T> instance() {
         return (OperatorDistinct<T, T>) Holder.INSTANCE;
     }
 
diff --git a/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java b/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
index 0d98b3248f..bbb60298cf 100644
--- a/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
+++ b/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
@@ -38,10 +38,11 @@ private static class Holder {
      * Returns a singleton instance of OperatorDistinctUntilChanged that was built using 
      * the identity function for comparison (<code>new OperatorDistinctUntilChanged(UtilityFunctions.identity())</code>).
      * 
+     * @param <T> the value type
      * @return Operator that emits sequentially distinct values only using the identity function for comparison 
      */
     @SuppressWarnings("unchecked")
-    public static <T> OperatorDistinctUntilChanged<T,T> instance() {
+    public static <T> OperatorDistinctUntilChanged<T, T> instance() {
         return (OperatorDistinctUntilChanged<T, T>) Holder.INSTANCE;
     }
 
diff --git a/src/main/java/rx/internal/operators/OperatorDoOnEach.java b/src/main/java/rx/internal/operators/OperatorDoOnEach.java
index 3e274b17c4..e0e71a2188 100644
--- a/src/main/java/rx/internal/operators/OperatorDoOnEach.java
+++ b/src/main/java/rx/internal/operators/OperatorDoOnEach.java
@@ -23,6 +23,7 @@
 
 /**
  * Converts the elements of an observable sequence to the specified type.
+ * @param <T> the value type
  */
 public class OperatorDoOnEach<T> implements Operator<T, T> {
     final Observer<? super T> doOnEachObserver;
diff --git a/src/main/java/rx/internal/operators/OperatorElementAt.java b/src/main/java/rx/internal/operators/OperatorElementAt.java
index 516e73f282..6f79d6a285 100644
--- a/src/main/java/rx/internal/operators/OperatorElementAt.java
+++ b/src/main/java/rx/internal/operators/OperatorElementAt.java
@@ -23,6 +23,7 @@
 
 /**
  * Returns the element at a specified index in a sequence.
+ * @param <T> the value type
  */
 public final class OperatorElementAt<T> implements Operator<T, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index 4fe29b6c2d..05fbd6445f 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -38,7 +38,7 @@
  *            the key type
  * @param <T>
  *            the source and group value type
- * @param <R>
+ * @param <V>
  *            the value type of the groups
  */
 public final class OperatorGroupBy<T, K, V> implements Operator<GroupedObservable<K, V>, T>{
diff --git a/src/main/java/rx/internal/operators/OperatorMapNotification.java b/src/main/java/rx/internal/operators/OperatorMapNotification.java
index e7a18cc202..77f85d04ad 100644
--- a/src/main/java/rx/internal/operators/OperatorMapNotification.java
+++ b/src/main/java/rx/internal/operators/OperatorMapNotification.java
@@ -27,6 +27,8 @@
  * this transformation as a new {@code Observable}.
  * <p>
  * <img width="640" height="305" src="https://raw.githubusercontent.com/wiki/ReactiveX/RxJava/images/rx-operators/map.png" alt="">
+ * @param <T> the input value type
+ * @param <R> the output value type
  */
 public final class OperatorMapNotification<T, R> implements Operator<R, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorMapPair.java b/src/main/java/rx/internal/operators/OperatorMapPair.java
index 3cba7d6bf8..5db9596b6b 100644
--- a/src/main/java/rx/internal/operators/OperatorMapPair.java
+++ b/src/main/java/rx/internal/operators/OperatorMapPair.java
@@ -38,6 +38,8 @@ public final class OperatorMapPair<T, U, R> implements Operator<Observable<? ext
     /**
      * Creates the function that generates a {@code Observable} based on an item emitted by another {@code Observable}.
      * 
+     * @param <T> the input value type
+     * @param <U> the value type of the generated Observable
      * @param selector
      *            a function that accepts an item and returns an {@code Iterable} of corresponding items
      * @return a function that converts an item emitted by the source {@code Observable} into an {@code Observable} that emits the items generated by {@code selector} operating on that item
diff --git a/src/main/java/rx/internal/operators/OperatorMaterialize.java b/src/main/java/rx/internal/operators/OperatorMaterialize.java
index 4a90f1f43f..75700b8d11 100644
--- a/src/main/java/rx/internal/operators/OperatorMaterialize.java
+++ b/src/main/java/rx/internal/operators/OperatorMaterialize.java
@@ -30,6 +30,7 @@
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/materialize.png" alt="">
  * <p>
  * See <a href="http://msdn.microsoft.com/en-us/library/hh229453.aspx">here</a> for the Microsoft Rx equivalent.
+ * @param <T> the value type
  */
 public final class OperatorMaterialize<T> implements Operator<Notification<T>, T> {
 
@@ -40,6 +41,7 @@ private static final class Holder {
     }
 
     /**
+     * @param <T> the value type
      * @return a singleton instance of this stateless operator.
      */
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/operators/OperatorMerge.java b/src/main/java/rx/internal/operators/OperatorMerge.java
index 1f7f95d2ef..3391d18cd8 100644
--- a/src/main/java/rx/internal/operators/OperatorMerge.java
+++ b/src/main/java/rx/internal/operators/OperatorMerge.java
@@ -64,6 +64,7 @@ private static final class HolderDelayErrors {
         static final OperatorMerge<Object> INSTANCE = new OperatorMerge<Object>(true, Integer.MAX_VALUE);
     }
     /**
+     * @param <T> the common value type
      * @param delayErrors should the merge delay errors?
      * @return a singleton instance of this stateless operator.
      */
@@ -76,9 +77,10 @@ public static <T> OperatorMerge<T> instance(boolean delayErrors) {
     }
     /**
      * Creates a new instance of the operator with the given delayError and maxConcurrency settings.
+     * @param <T> the value type
      * @param delayErrors
      * @param maxConcurrent the maximum number of concurrent subscriptions or Integer.MAX_VALUE for unlimited
-     * @return
+     * @return the Operator instance with the given settings
      */
     public static <T> OperatorMerge<T> instance(boolean delayErrors, int maxConcurrent) {
         if (maxConcurrent <= 0) {
diff --git a/src/main/java/rx/internal/operators/OperatorMulticast.java b/src/main/java/rx/internal/operators/OperatorMulticast.java
index 6b760161da..ee5551fcef 100644
--- a/src/main/java/rx/internal/operators/OperatorMulticast.java
+++ b/src/main/java/rx/internal/operators/OperatorMulticast.java
@@ -76,6 +76,7 @@ public void call(Subscriber<? super R> subscriber) {
         this.subjectFactory = subjectFactory;
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public void connect(Action1<? super Subscription> connection) {
         // each time we connect we create a new Subject and Subscription
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
index dee334bb4d..98f4f9479d 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
@@ -32,6 +32,7 @@ private static final class Holder {
     }
 
     /**
+     * @param <T> the value type
      * @return a singleton instance of this stateless operator.
      */
     @SuppressWarnings({ "unchecked" })
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java
index 15078b0614..02225d3afc 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java
@@ -23,6 +23,7 @@
 /**
  * An operator which drops all but the last received value in case the downstream
  * doesn't request more.
+ * @param <T> the value type
  */
 public final class OperatorOnBackpressureLatest<T> implements Operator<T, T> {
     /** Holds a singleton instance initialized on class-loading. */
@@ -32,6 +33,7 @@ static final class Holder {
     
     /**
      * Returns a singleton instance of the OnBackpressureLatest operator since it is stateless.
+     * @param <T> the value type
      * @return the single instanceof OperatorOnBackpressureLatest
      */
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java b/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
index 48a03ea30b..7f5b22c0a2 100644
--- a/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
+++ b/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
@@ -40,6 +40,7 @@
  * <p>
  * You can use this to prevent errors from propagating or to supply fallback data should errors be
  * encountered.
+ * @param <T> the value type
  */
 public final class OperatorOnErrorResumeNextViaFunction<T> implements Operator<T, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorPublish.java b/src/main/java/rx/internal/operators/OperatorPublish.java
index 347905e06e..1e5002e116 100644
--- a/src/main/java/rx/internal/operators/OperatorPublish.java
+++ b/src/main/java/rx/internal/operators/OperatorPublish.java
@@ -39,6 +39,7 @@ public final class OperatorPublish<T> extends ConnectableObservable<T> {
 
     /**
      * Creates a OperatorPublish instance to publish values of the given source observable.
+     * @param <T> the value type
      * @param source the source observable
      * @return the connectable observable
      */
diff --git a/src/main/java/rx/internal/operators/OperatorReplay.java b/src/main/java/rx/internal/operators/OperatorReplay.java
index 4ca4bda3e9..1d92afa637 100644
--- a/src/main/java/rx/internal/operators/OperatorReplay.java
+++ b/src/main/java/rx/internal/operators/OperatorReplay.java
@@ -47,9 +47,13 @@ public Object call() {
     /**
      * Given a connectable observable factory, it multicasts over the generated
      * ConnectableObservable via a selector function.
-     * @param connectableFactory
-     * @param selector
-     * @return
+     * @param <T> the upstream's value type
+     * @param <U> the intermediate value type of the ConnectableObservable
+     * @param <R> the final value type provided by the selector function
+     * @param connectableFactory the factory that returns a ConnectableObservable instance
+     * @param selector the function applied on the ConnectableObservable and returns the Observable
+     * the downstream will subscribe to.
+     * @return the Observable multicasting over a transformation of a ConnectableObserable
      */
     public static <T, U, R> Observable<R> multicastSelector(
             final Func0<? extends ConnectableObservable<U>> connectableFactory,
@@ -82,9 +86,10 @@ public void call(Subscription t) {
     /**
      * Child Subscribers will observe the events of the ConnectableObservable on the
      * specified scheduler.
-     * @param co
-     * @param scheduler
-     * @return
+     * @param <T> the value type
+     * @param co the ConnectableObservable to schedule on the specified scheduler
+     * @param scheduler the target Scheduler instance
+     * @return the ConnectableObservable instance that is observed on the specified scheduler
      */
     public static <T> ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler) {
         final Observable<T> observable = co.observeOn(scheduler);
@@ -118,8 +123,9 @@ public void connect(Action1<? super Subscription> connection) {
     
     /**
      * Creates a replaying ConnectableObservable with an unbounded buffer.
-     * @param source
-     * @return
+     * @param <T> the value type
+     * @param source the source Observable
+     * @return the replaying ConnectableObservable
      */
     @SuppressWarnings("unchecked")
     public static <T> ConnectableObservable<T> create(Observable<? extends T> source) {
@@ -128,10 +134,12 @@ public static <T> ConnectableObservable<T> create(Observable<? extends T> source
     
     /**
      * Creates a replaying ConnectableObservable with a size bound buffer.
-     * @param source
-     * @param bufferSize
-     * @return
+     * @param <T> the value type
+     * @param source the source Observable
+     * @param bufferSize the maximum number of elements buffered
+     * @return the replaying ConnectableObservable
      */
+    @SuppressWarnings("cast")
     public static <T> ConnectableObservable<T> create(Observable<? extends T> source, 
             final int bufferSize) {
         if (bufferSize == Integer.MAX_VALUE) {
@@ -147,12 +155,14 @@ public ReplayBuffer<T> call() {
 
     /**
      * Creates a replaying ConnectableObservable with a time bound buffer.
-     * @param source
-     * @param maxAge
-     * @param unit
-     * @param scheduler
-     * @return
+     * @param <T> the value type
+     * @param source the source Observable
+     * @param maxAge the maximum age (exclusive) of each item when timestamped with the given scheduler
+     * @param unit the time unit of the maximum age
+     * @param scheduler the scheduler providing the notion of current time
+     * @return the replaying ConnectableObservable
      */
+    @SuppressWarnings("cast")
     public static <T> ConnectableObservable<T> create(Observable<? extends T> source, 
             long maxAge, TimeUnit unit, Scheduler scheduler) {
         return (ConnectableObservable<T>)create(source, maxAge, unit, scheduler, Integer.MAX_VALUE);
@@ -160,12 +170,13 @@ public static <T> ConnectableObservable<T> create(Observable<? extends T> source
 
     /**
      * Creates a replaying ConnectableObservable with a size and time bound buffer.
-     * @param source
-     * @param maxAge
-     * @param unit
-     * @param scheduler
-     * @param bufferSize
-     * @return
+     * @param <T> the value type
+     * @param source the source Observable
+     * @param maxAge the maximum age (exclusive) of each item when timestamped with the given scheduler
+     * @param unit the time unit of the maximum age
+     * @param scheduler the scheduler providing the notion of current time
+     * @param bufferSize the maximum number of elements buffered
+     * @return the replaying ConnectableObservable
      */
     public static <T> ConnectableObservable<T> create(Observable<? extends T> source, 
             long maxAge, TimeUnit unit, final Scheduler scheduler, final int bufferSize) {
@@ -856,8 +867,6 @@ public void replay(InnerProducer<T> output) {
     
     /**
      * Represents a node in a bounded replay buffer's linked list.
-     *
-     * @param <T> the contained value type
      */
     static final class Node extends AtomicReference<Node> {
         /** */
diff --git a/src/main/java/rx/internal/operators/OperatorSampleWithObservable.java b/src/main/java/rx/internal/operators/OperatorSampleWithObservable.java
index f8065a610b..605ea96120 100644
--- a/src/main/java/rx/internal/operators/OperatorSampleWithObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorSampleWithObservable.java
@@ -24,7 +24,7 @@
 /**
  * Sample with the help of another observable.
  * 
- * @see <a href='http://msdn.microsoft.com/en-us/library/hh229742.aspx'>MSDN: Observable.Sample</a>
+ * @see <a href="http://msdn.microsoft.com/en-us/library/hh229742.aspx">MSDN: Observable.Sample</a>
  * 
  * @param <T> the source and result value type
  * @param <U> the element type of the sampler Observable
diff --git a/src/main/java/rx/internal/operators/OperatorSampleWithTime.java b/src/main/java/rx/internal/operators/OperatorSampleWithTime.java
index 39e783062c..e4c4a82c53 100644
--- a/src/main/java/rx/internal/operators/OperatorSampleWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorSampleWithTime.java
@@ -66,7 +66,7 @@ static final class SamplerSubscriber<T> extends Subscriber<T> implements Action0
         private static final Object EMPTY_TOKEN = new Object();
         /** The shared value between the observer and the timed action. */
         final AtomicReference<Object> value = new AtomicReference<Object>(EMPTY_TOKEN);
-        /** Updater for the value field. */
+
         public SamplerSubscriber(Subscriber<? super T> subscriber) {
             this.subscriber = subscriber;
         }
diff --git a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
index 06a30edcde..53deb16edf 100644
--- a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
+++ b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
@@ -50,6 +50,7 @@ public Object call(T t1) {
      * Tests whether two {@code Observable} sequences are identical, emitting {@code true} if both sequences
      * complete without differing, and {@code false} if the two sequences diverge at any point.
      *
+     * @param <T> the value type
      * @param first
      *      the first of the two {@code Observable}s to compare
      * @param second
diff --git a/src/main/java/rx/internal/operators/OperatorSerialize.java b/src/main/java/rx/internal/operators/OperatorSerialize.java
index a8d7dd4a47..9c313f450e 100644
--- a/src/main/java/rx/internal/operators/OperatorSerialize.java
+++ b/src/main/java/rx/internal/operators/OperatorSerialize.java
@@ -26,6 +26,7 @@ private static final class Holder {
         static final OperatorSerialize<Object> INSTANCE = new OperatorSerialize<Object>();
     }
     /**
+     * @param <T> the value type
      * @return a singleton instance of this stateless operator.
      */
     @SuppressWarnings({ "unchecked" })
diff --git a/src/main/java/rx/internal/operators/OperatorSingle.java b/src/main/java/rx/internal/operators/OperatorSingle.java
index f8415b9a20..2ecdbfecb0 100644
--- a/src/main/java/rx/internal/operators/OperatorSingle.java
+++ b/src/main/java/rx/internal/operators/OperatorSingle.java
@@ -26,6 +26,7 @@
  * If the Observable completes after emitting a single item that matches a
  * predicate, return an Observable containing that item. If it emits more than
  * one such item or no item, throw an IllegalArgumentException.
+ * @param <T> the value type
  */
 public final class OperatorSingle<T> implements Operator<T, T> {
 
@@ -40,6 +41,7 @@ private static class Holder {
      * Returns a singleton instance of OperatorSingle (if the stream is empty or has 
      * more than one element an error will be emitted) that is cast to the generic type.
      *  
+     * @param <T> the value type
      * @return a singleton instance of an Operator that will emit a single value only unless the stream has zero or more than one element in which case it will emit an error.
      */
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/operators/OperatorSkip.java b/src/main/java/rx/internal/operators/OperatorSkip.java
index bc63fe5e21..6b06fe47b4 100644
--- a/src/main/java/rx/internal/operators/OperatorSkip.java
+++ b/src/main/java/rx/internal/operators/OperatorSkip.java
@@ -25,6 +25,7 @@
  * <p>
  * You can ignore the first <code>num</code> items emitted by an Observable and attend only to
  * those items that come after, by modifying the Observable with the {@code skip} operator.
+ * @param <T> the value type
  */
 public final class OperatorSkip<T> implements Observable.Operator<T, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorSkipLast.java b/src/main/java/rx/internal/operators/OperatorSkipLast.java
index be877a6b48..87276382bb 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipLast.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipLast.java
@@ -23,6 +23,7 @@
 
 /**
  * Bypasses a specified number of elements at the end of an observable sequence.
+ * @param <T> the value type
  */
 public class OperatorSkipLast<T> implements Operator<T, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorSkipLastTimed.java b/src/main/java/rx/internal/operators/OperatorSkipLastTimed.java
index 6bc24579ae..b3fe766308 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipLastTimed.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipLastTimed.java
@@ -26,6 +26,7 @@
 
 /**
  * Skip delivering values in the time window before the values.
+ * @param <T> the value type
  */
 public class OperatorSkipLastTimed<T> implements Operator<T, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorSkipUntil.java b/src/main/java/rx/internal/operators/OperatorSkipUntil.java
index 109fe84d5b..e4270b2010 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipUntil.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipUntil.java
@@ -27,7 +27,7 @@
  * 
  * If the secondary Observable fires no elements, the primary won't fire any elements.
  * 
- * @see <a href='http://msdn.microsoft.com/en-us/library/hh229358.aspx'>MSDN: Observable.SkipUntil</a>
+ * @see <a href="http://msdn.microsoft.com/en-us/library/hh229358.aspx">MSDN: Observable.SkipUntil</a>
  * 
  * @param <T> the source and result value type
  * @param <U> element type of the signalling observable
diff --git a/src/main/java/rx/internal/operators/OperatorSkipWhile.java b/src/main/java/rx/internal/operators/OperatorSkipWhile.java
index deea70afcd..b62e7f24a5 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipWhile.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipWhile.java
@@ -24,6 +24,7 @@
 /**
  * Skips any emitted source items as long as the specified condition holds true. Emits all further source items
  * as soon as the condition becomes false.
+ * @param <T> the value type
  */
 public final class OperatorSkipWhile<T> implements Operator<T, T> {
     final Func2<? super T, Integer, Boolean> predicate;
@@ -68,7 +69,12 @@ public void onCompleted() {
             }
         };
     }
-    /** Convert to Func2 type predicate. */
+    /** 
+     * Convert to Func2 type predicate.
+     * @param <T> the input value type
+     * @param predicate the single argument predicate function
+     * @return The two argument function which ignores its second parameter  
+     */
     public static <T> Func2<T, Integer, Boolean> toPredicate2(final Func1<? super T, Boolean> predicate) {
         return new Func2<T, Integer, Boolean>() {
 
diff --git a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java b/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
index e14d9ace16..c1473c69eb 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
+++ b/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
@@ -24,6 +24,7 @@
  * If the Observable completes without emitting any items, subscribe to an alternate Observable. Allows for similar
  * functionality to {@link rx.internal.operators.OperatorDefaultIfEmpty} except instead of one item being emitted when
  * empty, the results of the given Observable will be emitted.
+ * @param <T> the value type
  */
 public final class OperatorSwitchIfEmpty<T> implements Observable.Operator<T, T> {
     private final Observable<? extends T> alternate;
diff --git a/src/main/java/rx/internal/operators/OperatorTake.java b/src/main/java/rx/internal/operators/OperatorTake.java
index 55b0288f12..d08c5a3b92 100644
--- a/src/main/java/rx/internal/operators/OperatorTake.java
+++ b/src/main/java/rx/internal/operators/OperatorTake.java
@@ -30,6 +30,7 @@
  * the {@code take} operator. This operator returns an {@code Observable} that will invoke a subscriber's
  * {@link Subscriber#onNext onNext} function a maximum of {@code num} times before invoking
  * {@link Subscriber#onCompleted onCompleted}.
+ * @param <T> the value type
  */
 public final class OperatorTake<T> implements Operator<T, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorTakeUntil.java b/src/main/java/rx/internal/operators/OperatorTakeUntil.java
index 9c0f131b1f..dad80632b4 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeUntil.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeUntil.java
@@ -25,6 +25,8 @@
  * emits an item.
  * <p>
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/takeUntil.png" alt="">
+ * @param <T> the value type of the 'main' source
+ * @param <E> the value type of the 'until' sequence
  */
 public final class OperatorTakeUntil<T, E> implements Operator<T, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java b/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
index 36ce00271b..8ed22f9108 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
@@ -24,6 +24,7 @@
  * Returns an Observable that emits items emitted by the source Observable until
  * the provided predicate returns false
  * <p>
+ * @param <T> the value type
  */
 public final class OperatorTakeUntilPredicate<T> implements Operator<T, T> {
     /** Subscriber returned to the upstream. */
diff --git a/src/main/java/rx/internal/operators/OperatorTakeWhile.java b/src/main/java/rx/internal/operators/OperatorTakeWhile.java
index e241ace057..2a5fdc5bc0 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeWhile.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeWhile.java
@@ -25,6 +25,7 @@
  * condition is true.
  * <p>
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/takeWhile.png" alt="">
+ * @param <T> the value type
  */
 public final class OperatorTakeWhile<T> implements Operator<T, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorThrottleFirst.java b/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
index 2bf960931d..906b207856 100644
--- a/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
+++ b/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
@@ -22,6 +22,7 @@
 
 /**
  * Throttle by windowing a stream and returning the first value in each window.
+ * @param <T> the value type
  */
 public final class OperatorThrottleFirst<T> implements Operator<T, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorTimeInterval.java b/src/main/java/rx/internal/operators/OperatorTimeInterval.java
index e73f6fd0d3..606f4d529f 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeInterval.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeInterval.java
@@ -22,6 +22,7 @@
 
 /**
  * Records the time interval between consecutive elements in an observable sequence.
+ * @param <T> the value type
  */
 public final class OperatorTimeInterval<T> implements Operator<TimeInterval<T>, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorTimeout.java b/src/main/java/rx/internal/operators/OperatorTimeout.java
index f1278c933c..8234669508 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeout.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeout.java
@@ -28,6 +28,7 @@
  * received within the specified timeout duration starting from its predecessor,
  * the other observable sequence is used to produce future messages from that
  * point on.
+ * @param <T> the value type
  */
 public final class OperatorTimeout<T> extends OperatorTimeoutBase<T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java b/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
index eff265e4e5..1e6c20e8a2 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
@@ -30,6 +30,9 @@
  * item emitted by the source Observable or any subsequent item don't arrive
  * within time windows defined by provided Observables, switch to the
  * <code>other</code> Observable if provided, or emit a TimeoutException .
+ * @param <T> the value type of the main Observable
+ * @param <U> the value type of the first timeout Observable
+ * @param <V> the value type of the subsequent timeout Observable
  */
 public class OperatorTimeoutWithSelector<T, U, V> extends
         OperatorTimeoutBase<T> {
diff --git a/src/main/java/rx/internal/operators/OperatorTimestamp.java b/src/main/java/rx/internal/operators/OperatorTimestamp.java
index 284c0e2124..5d0706afa4 100644
--- a/src/main/java/rx/internal/operators/OperatorTimestamp.java
+++ b/src/main/java/rx/internal/operators/OperatorTimestamp.java
@@ -24,6 +24,7 @@
  * Wraps each item emitted by a source {@code Observable} in a {@link Timestamped} object.
  * <p>
  * <img width="640" height="310" src="https://raw.githubusercontent.com/wiki/ReactiveX/RxJava/images/rx-operators/timestamp.png" alt="">
+ * @param <T> the value type
  */
 public final class OperatorTimestamp<T> implements Operator<Timestamped<T>, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorToMap.java b/src/main/java/rx/internal/operators/OperatorToMap.java
index 0bd9e918a3..aa82c49cc4 100644
--- a/src/main/java/rx/internal/operators/OperatorToMap.java
+++ b/src/main/java/rx/internal/operators/OperatorToMap.java
@@ -30,12 +30,17 @@
  * Maps the elements of the source observable into a java.util.Map instance and
  * emits that once the source observable completes.
  * 
- * @see <a href='https://github.com/ReactiveX/RxJava/issues/96'>Issue #96</a>
+ * @see <a href="https://github.com/ReactiveX/RxJava/issues/96">Issue #96</a>
+ * @param <T> the value type of the input
+ * @param <K> the map-key type
+ * @param <V> the map-value type
  */
 public final class OperatorToMap<T, K, V> implements Operator<Map<K, V>, T> {
 
     /**
      * The default map factory.
+     * @param <K> the key type
+     * @param <V> the value type
      */
     public static final class DefaultToMapFactory<K, V> implements Func0<Map<K, V>> {
         @Override
@@ -54,6 +59,8 @@ public Map<K, V> call() {
 
     /**
      * ToMap with key selector, value selector and default HashMap factory.
+     * @param keySelector the function extracting the map-key from the main value
+     * @param valueSelector the function extracting the map-value from the main value
      */
     public OperatorToMap(
             Func1<? super T, ? extends K> keySelector,
@@ -64,6 +71,9 @@ public OperatorToMap(
 
     /**
      * ToMap with key selector, value selector and custom Map factory.
+     * @param keySelector the function extracting the map-key from the main value
+     * @param valueSelector the function extracting the map-value from the main value
+     * @param mapFactory function that returns a Map instance to store keys and values into
      */
     public OperatorToMap(
             Func1<? super T, ? extends K> keySelector,
diff --git a/src/main/java/rx/internal/operators/OperatorToMultimap.java b/src/main/java/rx/internal/operators/OperatorToMultimap.java
index 6fee7620a9..fe753fee95 100644
--- a/src/main/java/rx/internal/operators/OperatorToMultimap.java
+++ b/src/main/java/rx/internal/operators/OperatorToMultimap.java
@@ -33,11 +33,16 @@
  * (Map&lt;K, Collection&lt;V>>) where each
  * key entry has a collection of the source's values.
  *
- * @see <a href='https://github.com/ReactiveX/RxJava/issues/97'>Issue #97</a>
+ * @see <a href="https://github.com/ReactiveX/RxJava/issues/97">Issue #97</a>
+ * @param <T> the value type of the input
+ * @param <K> the multimap-key type
+ * @param <V> the multimap-value type
  */
 public final class OperatorToMultimap<T, K, V> implements Operator<Map<K, Collection<V>>, T> {
     /**
      * The default multimap factory returning a HashMap.
+     * @param <K> the key type
+     * @param <V> the value type
      */
     public static final class DefaultToMultimapFactory<K, V> implements Func0<Map<K, Collection<V>>> {
         @Override
@@ -49,6 +54,8 @@ public Map<K, Collection<V>> call() {
     /**
      * The default collection factory for a key in the multimap returning
      * an ArrayList independent of the key.
+     * @param <K> the key type
+     * @param <V> the value type
      */
     public static final class DefaultMultimapCollectionFactory<K, V>
             implements Func1<K, Collection<V>> {
@@ -66,6 +73,8 @@ public Collection<V> call(K t1) {
     /**
      * ToMultimap with key selector, custom value selector,
      * default HashMap factory and default ArrayList collection factory.
+     * @param keySelector the function extracting the map-key from the main value
+     * @param valueSelector the function extracting the map-value from the main value
      */
     public OperatorToMultimap(
             Func1<? super T, ? extends K> keySelector,
@@ -78,6 +87,9 @@ public OperatorToMultimap(
     /**
      * ToMultimap with key selector, custom value selector,
      * custom Map factory and default ArrayList collection factory.
+     * @param keySelector the function extracting the map-key from the main value
+     * @param valueSelector the function extracting the map-value from the main value
+     * @param mapFactory function that returns a Map instance to store keys and values into
      */
     public OperatorToMultimap(
             Func1<? super T, ? extends K> keySelector,
@@ -91,6 +103,10 @@ public OperatorToMultimap(
     /**
      * ToMultimap with key selector, custom value selector,
      * custom Map factory and custom collection factory.
+     * @param keySelector the function extracting the map-key from the main value
+     * @param valueSelector the function extracting the map-value from the main value
+     * @param mapFactory function that returns a Map instance to store keys and values into
+     * @param collectionFactory function that returns a Collection for a particular key to store values into
      */
     public OperatorToMultimap(
             Func1<? super T, ? extends K> keySelector,
diff --git a/src/main/java/rx/internal/operators/OperatorToObservableList.java b/src/main/java/rx/internal/operators/OperatorToObservableList.java
index 66e0bb188a..518a9a37c1 100644
--- a/src/main/java/rx/internal/operators/OperatorToObservableList.java
+++ b/src/main/java/rx/internal/operators/OperatorToObservableList.java
@@ -35,6 +35,7 @@
  * <p>
  * Be careful not to use this operator on {@code Observable}s that emit infinite or very large numbers of items,
  * as you do not have the option to unsubscribe.
+ * @param <T> the value type of the input and the output list's items
  */
 public final class OperatorToObservableList<T> implements Operator<List<T>, T> {
     /** Lazy initialization via inner-class holder. */
@@ -43,6 +44,7 @@ private static final class Holder {
         static final OperatorToObservableList<Object> INSTANCE = new OperatorToObservableList<Object>();
     }
     /**
+     * @param <T> the value type of the input and the output list's items
      * @return a singleton instance of this stateless operator.
      */
     @SuppressWarnings({ "unchecked" })
diff --git a/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java b/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
index 327b4d1d24..f0b0151063 100644
--- a/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
+++ b/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
@@ -24,6 +24,7 @@
 /**
  * Unsubscribes on the specified Scheduler.
  * <p>
+ * @param <T> the value type
  */
 public class OperatorUnsubscribeOn<T> implements Operator<T, T> {
 
diff --git a/src/main/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOther.java b/src/main/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOther.java
index a2d47dfee7..41d0383ac9 100644
--- a/src/main/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOther.java
+++ b/src/main/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOther.java
@@ -38,6 +38,7 @@ public SingleOnSubscribeDelaySubscriptionOther(Single<? extends T> main, Observa
         this.other = other;
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public void call(final SingleSubscriber<? super T> subscriber) {
         final SingleSubscriber<T> child = new SingleSubscriber<T>() {

From 9710f0632e94ea76a5b6261085da1453ae244926 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 1 Jun 2016 05:52:37 +0200
Subject: [PATCH 036/263] 1.x: add termination clarification to switchMap
 operators (#3974)

Closes  #3576 .
---
 src/main/java/rx/Observable.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index cad9d2d0f7..cf2149bc6d 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -2846,6 +2846,9 @@ public static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> firs
      * these emitted Observables, the Observable returned by {@code switchOnNext} begins emitting the items
      * emitted by that Observable. When a new Observable is emitted, {@code switchOnNext} stops emitting items
      * from the earlier-emitted Observable and begins emitting items from the new one.
+     * <p>
+     * The resulting Observable completes if both the outer Observable and the last inner Observable, if any, complete.
+     * If the outer Observable signals an onError, the inner Observable is unsubscribed and the error delivered in-sequence.
      * <dl>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code switchOnNext} does not operate by default on a particular {@link Scheduler}.</dd>
@@ -2872,6 +2875,10 @@ public static <T> Observable<T> switchOnNext(Observable<? extends Observable<? e
      * these emitted Observables, the Observable returned by {@code switchOnNext} begins emitting the items
      * emitted by that Observable. When a new Observable is emitted, {@code switchOnNext} stops emitting items
      * from the earlier-emitted Observable and begins emitting items from the new one.
+     * <p>
+     * The resulting Observable completes if both the main Observable and the last inner Observable, if any, complete.
+     * If the main Observable signals an onError, the termination of the last inner Observable will emit that error as is
+     * or wrapped into a CompositeException along with the other possible errors the former inner Observables signalled.
      * <dl>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code switchOnNext} does not operate by default on a particular {@link Scheduler}.</dd>
@@ -8619,6 +8626,9 @@ public final Observable<T> subscribeOn(Scheduler scheduler) {
      * Observable that returns an Observable, and then emitting the items emitted by the most recently emitted
      * of these Observables.
      * <p>
+     * The resulting Observable completes if both the upstream Observable and the last inner Observable, if any, complete.
+     * If the upstream Observable signals an onError, the inner Observable is unsubscribed and the error delivered in-sequence.
+     * <p>
      * <img width="640" height="350" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/switchMap.png" alt="">
      * <dl>
      *  <dt><b>Scheduler:</b></dt>
@@ -8640,6 +8650,10 @@ public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<?
      * Observable that returns an Observable, and then emitting the items emitted by the most recently emitted
      * of these Observables and delays any error until all Observables terminate.
      * <p>
+     * The resulting Observable completes if both the upstream Observable and the last inner Observable, if any, complete.
+     * If the upstream Observable signals an onError, the termination of the last inner Observable will emit that error as is
+     * or wrapped into a CompositeException along with the other possible errors the former inner Observables signalled.
+     * <p>
      * <img width="640" height="350" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/switchMap.png" alt="">
      * <dl>
      *  <dt><b>Scheduler:</b></dt>

From 44947d94422f68eaf5b46eddc29eebae427297e3 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 1 Jun 2016 13:02:27 +0200
Subject: [PATCH 037/263] 1.x: benchmark just and Single (#3982)

* 1.x: benchmark just and Single

* Adjust header date
---
 src/perf/java/rx/OneItemPerf.java             | 230 ++++++++++++++++++
 .../rx/jmh/PerfAsyncSingleSubscriber.java     |  69 ++++++
 .../java/rx/jmh/PerfSingleSubscriber.java     |  42 ++++
 3 files changed, 341 insertions(+)
 create mode 100644 src/perf/java/rx/OneItemPerf.java
 create mode 100644 src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java
 create mode 100644 src/perf/java/rx/jmh/PerfSingleSubscriber.java

diff --git a/src/perf/java/rx/OneItemPerf.java b/src/perf/java/rx/OneItemPerf.java
new file mode 100644
index 0000000000..c864164db8
--- /dev/null
+++ b/src/perf/java/rx/OneItemPerf.java
@@ -0,0 +1,230 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx;
+
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+
+import rx.Observable.OnSubscribe;
+import rx.functions.Func1;
+import rx.internal.producers.SingleProducer;
+import rx.jmh.*;
+
+/**
+ * Benchmark operators working on a one-item source.
+ * <p>
+ * gradlew benchmarks "-Pjmh=-f 1 -tu s -bm thrpt -wi 5 -i 5 -r 1 .*OneItemPerf.*"
+ * <p>
+ * gradlew benchmarks "-Pjmh=-f 1 -tu ns -bm avgt -wi 5 -i 5 -r 1 .*OneItemPerf.*"
+ */
+@BenchmarkMode(Mode.Throughput)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@State(Scope.Thread)
+public class OneItemPerf {
+    
+    Observable<Integer> scalar;
+    Observable<Integer> scalarHidden;
+    Observable<Integer> one;
+    Single<Integer> single;
+    Single<Integer> singleHidden;
+
+    Observable<Integer> scalarConcat;
+    Observable<Integer> scalarHiddenConcat;
+    Observable<Integer> oneConcat;
+
+    Observable<Integer> scalarMerge;
+    Observable<Integer> scalarHiddenMerge;
+    Observable<Integer> oneMerge;
+    Single<Integer> singleMerge;
+    Single<Integer> singleHiddenMerge;
+
+    Observable<Integer> scalarSwitch;
+    Observable<Integer> scalarHiddenSwitch;
+    Observable<Integer> oneSwitch;
+    
+    <T> Single<T> hide(final Single<T> single) {
+        return Single.create(new Single.OnSubscribe<T>() {
+            @Override
+            public void call(SingleSubscriber<? super T> t) {
+                single.subscribe(t);
+            }
+        });
+    }
+    
+    @Setup
+    public void setup() {
+        scalar = Observable.just(1);
+        one = Observable.create(new OnSubscribe<Integer>() {
+            @Override
+            public void call(Subscriber<? super Integer> t) {
+                t.setProducer(new SingleProducer<Integer>(t, 1));
+            }
+        });
+        single = Single.just(1);
+        singleHidden = hide(single);
+        scalarHidden = scalar.asObservable();
+        
+        // ----------------------------------------------------------------------------
+        
+        scalarConcat = scalar.concatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return scalar;
+            }
+        });
+        scalarHiddenConcat = scalarHidden.concatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return scalar;
+            }
+        });
+        
+        oneConcat  = one.concatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return scalar;
+            }
+        });
+
+        // ----------------------------------------------------------------------------
+
+        scalarMerge = scalar.flatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return scalar;
+            }
+        });
+        scalarHiddenMerge = scalarHidden.flatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return scalar;
+            }
+        });
+        
+        oneMerge  = one.flatMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return scalar;
+            }
+        });
+        singleMerge = single.flatMap(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return single;
+            }
+        });
+        singleHiddenMerge = hide(single).flatMap(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return single;
+            }
+        });
+        
+        // ----------------------------------------------------------------------------
+        
+        scalarSwitch = scalar.switchMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return scalar;
+            }
+        });
+        scalarHiddenSwitch = scalarHidden.switchMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return scalar;
+            }
+        });
+        
+        oneSwitch  = one.switchMap(new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer v) {
+                return scalar;
+            }
+        });
+    }
+    
+    @Benchmark
+    public void scalar(Blackhole bh) {
+        scalar.subscribe(new LatchedObserver<Integer>(bh));
+    }
+    @Benchmark
+    public void scalarHidden(Blackhole bh) {
+        scalarHidden.subscribe(new LatchedObserver<Integer>(bh));
+    }
+    @Benchmark
+    public void one(Blackhole bh) {
+        one.subscribe(new LatchedObserver<Integer>(bh));
+    }
+    @Benchmark
+    public void single(Blackhole bh) {
+        single.subscribe(new PerfSingleSubscriber(bh));
+    }
+    @Benchmark
+    public void singleHidden(Blackhole bh) {
+        singleHidden.subscribe(new PerfSingleSubscriber(bh));
+    }
+
+    @Benchmark
+    public void scalarConcat(Blackhole bh) {
+        scalarConcat.subscribe(new LatchedObserver<Integer>(bh));
+    }
+    @Benchmark
+    public void scalarHiddenConcat(Blackhole bh) {
+        scalarHidden.subscribe(new LatchedObserver<Integer>(bh));
+    }
+    @Benchmark
+    public void oneConcat(Blackhole bh) {
+        oneConcat.subscribe(new LatchedObserver<Integer>(bh));
+    }
+
+    @Benchmark
+    public void scalarMerge(Blackhole bh) {
+        scalarMerge.subscribe(new LatchedObserver<Integer>(bh));
+    }
+    @Benchmark
+    public void scalarHiddenMerge(Blackhole bh) {
+        scalarHidden.subscribe(new LatchedObserver<Integer>(bh));
+    }
+    @Benchmark
+    public void oneMerge(Blackhole bh) {
+        oneMerge.subscribe(new LatchedObserver<Integer>(bh));
+    }
+    @Benchmark
+    public void singleMerge(Blackhole bh) {
+        single.subscribe(new PerfSingleSubscriber(bh));
+    }
+    @Benchmark
+    public void singleHiddenMerge(Blackhole bh) {
+        singleHiddenMerge.subscribe(new PerfSingleSubscriber(bh));
+    }
+
+    @Benchmark
+    public void scalarSwitch(Blackhole bh) {
+        scalarSwitch.subscribe(new LatchedObserver<Integer>(bh));
+    }
+    @Benchmark
+    public void scalarHiddenSwitch(Blackhole bh) {
+        scalarHiddenSwitch.subscribe(new LatchedObserver<Integer>(bh));
+    }
+    @Benchmark
+    public void oneSwitch(Blackhole bh) {
+        oneSwitch.subscribe(new LatchedObserver<Integer>(bh));
+    }
+
+}
diff --git a/src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java b/src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java
new file mode 100644
index 0000000000..dba6f563df
--- /dev/null
+++ b/src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java
@@ -0,0 +1,69 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.jmh;
+
+import java.util.concurrent.CountDownLatch;
+
+import org.openjdk.jmh.infra.Blackhole;
+
+import rx.SingleSubscriber;
+
+/**
+ * A SingleSubscriber implementation for asynchronous benchmarks that sends
+ * the onSuccess and onError signals to a JMH Blackhole.
+ * <p>
+ * Use {@code sleepAwait} or {@code spinAwait}.
+ */
+public final class PerfAsyncSingleSubscriber extends SingleSubscriber<Object> {
+    final Blackhole bh;
+    
+    final CountDownLatch cdl;
+    
+    public PerfAsyncSingleSubscriber(Blackhole bh) {
+        this.bh = bh;
+        this.cdl = new CountDownLatch(1);
+    }
+    
+    @Override
+    public void onSuccess(Object value) {
+        bh.consume(value);
+        cdl.countDown();
+    }
+    
+    @Override
+    public void onError(Throwable error) {
+        bh.consume(error);
+        cdl.countDown();
+    }
+    
+    /**
+     * Sleeps until the subscriber receives an event.
+     */
+    public void sleepAwait() {
+        try {
+            cdl.await();
+        } catch (InterruptedException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+    
+    /**
+     * Spins until the subscriber receives an events.
+     */
+    public void spinAwait() {
+        while (cdl.getCount() != 0) ;
+    }
+}
diff --git a/src/perf/java/rx/jmh/PerfSingleSubscriber.java b/src/perf/java/rx/jmh/PerfSingleSubscriber.java
new file mode 100644
index 0000000000..d46f6a99bf
--- /dev/null
+++ b/src/perf/java/rx/jmh/PerfSingleSubscriber.java
@@ -0,0 +1,42 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.jmh;
+
+import org.openjdk.jmh.infra.Blackhole;
+
+import rx.SingleSubscriber;
+
+/**
+ * A SingleSubscriber implementation for synchronous benchmarks that sends
+ * the onSuccess and onError signals to a JMH Blackhole.
+ */
+public final class PerfSingleSubscriber extends SingleSubscriber<Object> {
+    final Blackhole bh;
+    
+    public PerfSingleSubscriber(Blackhole bh) {
+        this.bh = bh;
+    }
+    
+    @Override
+    public void onSuccess(Object value) {
+        bh.consume(value);
+    }
+    
+    @Override
+    public void onError(Throwable error) {
+        bh.consume(error);
+    }
+}

From 4b61060d8d3de5d58d66494d578730ef37bef092 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 1 Jun 2016 19:06:52 +0200
Subject: [PATCH 038/263] 1.x: add Completable.safeSubscribe option +
 RxJavaPlugins hook support (#3942)

Add option to safely subscribe a CompletableSubscriber / regular Subscriber and handle onXXX failures.
---
 src/main/java/rx/Completable.java             | 180 ++++++++----
 src/main/java/rx/Single.java                  |   2 +-
 .../CompletableOnSubscribeConcat.java         |   2 +-
 .../CompletableOnSubscribeConcatArray.java    |   2 +-
 .../CompletableOnSubscribeConcatIterable.java |   2 +-
 .../CompletableOnSubscribeMerge.java          |   2 +-
 .../CompletableOnSubscribeMergeArray.java     |   2 +-
 ...etableOnSubscribeMergeDelayErrorArray.java |   2 +-
 ...bleOnSubscribeMergeDelayErrorIterable.java |   2 +-
 .../CompletableOnSubscribeMergeIterable.java  |   2 +-
 .../CompletableOnSubscribeTimeout.java        |   4 +-
 .../observers/SafeCompletableSubscriber.java  |  94 ++++++
 .../RxJavaCompletableExecutionHook.java       | 104 +++++++
 src/main/java/rx/plugins/RxJavaPlugins.java   |  47 +++
 src/test/java/rx/CompletableTest.java         | 272 ++++++++++++++++--
 src/test/java/rx/SingleTest.java              |   4 +-
 .../operators/OnSubscribeCompletableTest.java |  12 +-
 .../java/rx/plugins/RxJavaPluginsTest.java    |  59 +++-
 18 files changed, 685 insertions(+), 109 deletions(-)
 create mode 100644 src/main/java/rx/observers/SafeCompletableSubscriber.java
 create mode 100644 src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 4f2eda83df..b5f9baebb7 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -26,6 +26,7 @@
 import rx.functions.*;
 import rx.internal.operators.*;
 import rx.internal.util.*;
+import rx.observers.*;
 import rx.plugins.*;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.*;
@@ -37,6 +38,12 @@
  */
 @Experimental
 public class Completable {
+    /** The error handler instance. */
+    static final RxJavaErrorHandler ERROR_HANDLER = RxJavaPlugins.getInstance().getErrorHandler();
+    
+    /** The completable hook. */
+    static RxJavaCompletableExecutionHook HOOK = RxJavaPlugins.getInstance().getCompletableExecutionHook();
+
     /**
      * Callback used for building deferred computations that takes a CompletableSubscriber.
      */
@@ -100,9 +107,6 @@ public void call(CompletableSubscriber s) {
         }
     });
     
-    /** The error handler instance. */
-    static final RxJavaErrorHandler ERROR_HANDLER = RxJavaPlugins.getInstance().getErrorHandler();
-    
     /**
      * Returns a Completable which terminates as soon as one of the source Completables
      * terminates (normally or with an error) and cancels all other Completables.
@@ -172,7 +176,7 @@ public void onSubscribe(Subscription d) {
                     }
                     
                     // no need to have separate subscribers because inner is stateless
-                    c.subscribe(inner);
+                    c.unsafeSubscribe(inner);
                 }
             }
         });
@@ -300,7 +304,7 @@ public void onSubscribe(Subscription d) {
                     }
                     
                     // no need to have separate subscribers because inner is stateless
-                    c.subscribe(inner);
+                    c.unsafeSubscribe(inner);
                 }
             }
         });
@@ -378,8 +382,6 @@ public static Completable concat(Observable<? extends Completable> sources, int
     public static Completable create(CompletableOnSubscribe onSubscribe) {
         requireNonNull(onSubscribe);
         try {
-            // TODO plugin wrapping onSubscribe
-            
             return new Completable(onSubscribe);
         } catch (NullPointerException ex) {
             throw ex;
@@ -415,7 +417,7 @@ public void call(CompletableSubscriber s) {
                     return;
                 }
                 
-                c.subscribe(s);
+                c.unsafeSubscribe(s);
             }
         });
     }
@@ -898,7 +900,7 @@ public void call(final CompletableSubscriber s) {
                 
                 final AtomicBoolean once = new AtomicBoolean();
                 
-                cs.subscribe(new CompletableSubscriber() {
+                cs.unsafeSubscribe(new CompletableSubscriber() {
                     Subscription d;
                     void dispose() {
                         d.unsubscribe();
@@ -974,7 +976,7 @@ public void call() {
      * not null (not verified)
      */
     protected Completable(CompletableOnSubscribe onSubscribe) {
-        this.onSubscribe = onSubscribe;
+        this.onSubscribe = HOOK.onCreate(onSubscribe);
     }
     
     /**
@@ -998,7 +1000,7 @@ public final void await() {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
         
-        subscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new CompletableSubscriber() {
 
             @Override
             public void onCompleted() {
@@ -1049,7 +1051,7 @@ public final boolean await(long timeout, TimeUnit unit) {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
         
-        subscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new CompletableSubscriber() {
 
             @Override
             public void onCompleted() {
@@ -1202,7 +1204,7 @@ public void call(final CompletableSubscriber s) {
                 final Scheduler.Worker w = scheduler.createWorker();
                 set.add(w);
                 
-                subscribe(new CompletableSubscriber() {
+                unsafeSubscribe(new CompletableSubscriber() {
 
                     
                     @Override
@@ -1314,7 +1316,7 @@ protected final Completable doOnLifecycle(
         return create(new CompletableOnSubscribe() {
             @Override
             public void call(final CompletableSubscriber s) {
-                subscribe(new CompletableSubscriber() {
+                unsafeSubscribe(new CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
@@ -1449,7 +1451,7 @@ public final Throwable get() {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
         
-        subscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new CompletableSubscriber() {
 
             @Override
             public void onCompleted() {
@@ -1493,7 +1495,7 @@ public final Throwable get(long timeout, TimeUnit unit) {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
         
-        subscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new CompletableSubscriber() {
 
             @Override
             public void onCompleted() {
@@ -1541,11 +1543,10 @@ public final Completable lift(final CompletableOperator onLift) {
             @Override
             public void call(CompletableSubscriber s) {
                 try {
-                    // TODO plugin wrapping
-
-                    CompletableSubscriber sw = onLift.call(s);
+                    CompletableOperator onLiftDecorated = HOOK.onLift(onLift);
+                    CompletableSubscriber sw = onLiftDecorated.call(s);
                     
-                    subscribe(sw);
+                    unsafeSubscribe(sw);
                 } catch (NullPointerException ex) {
                     throw ex;
                 } catch (Throwable ex) {
@@ -1586,7 +1587,7 @@ public void call(final CompletableSubscriber s) {
                 
                 s.onSubscribe(ad);
                 
-                subscribe(new CompletableSubscriber() {
+                unsafeSubscribe(new CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
@@ -1648,7 +1649,7 @@ public final Completable onErrorComplete(final Func1<? super Throwable, Boolean>
         return create(new CompletableOnSubscribe() {
             @Override
             public void call(final CompletableSubscriber s) {
-                subscribe(new CompletableSubscriber() {
+                unsafeSubscribe(new CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
@@ -1697,7 +1698,7 @@ public final Completable onErrorResumeNext(final Func1<? super Throwable, ? exte
             @Override
             public void call(final CompletableSubscriber s) {
                 final SerialSubscription sd = new SerialSubscription();
-                subscribe(new CompletableSubscriber() {
+                unsafeSubscribe(new CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
@@ -1723,7 +1724,7 @@ public void onError(Throwable e) {
                             return;
                         }
                         
-                        c.subscribe(new CompletableSubscriber() {
+                        c.unsafeSubscribe(new CompletableSubscriber() {
 
                             @Override
                             public void onCompleted() {
@@ -1859,7 +1860,7 @@ public final <T> Observable<T> startWith(Observable<T> other) {
      */
     public final Subscription subscribe() {
         final MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
-        subscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onCompleted() {
                 mad.unsubscribe();
@@ -1892,16 +1893,20 @@ public final Subscription subscribe(final Action0 onComplete) {
         requireNonNull(onComplete);
         
         final MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
-        subscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new CompletableSubscriber() {
+            boolean done;
             @Override
             public void onCompleted() {
-                try {
-                    onComplete.call();
-                } catch (Throwable e) {
-                    ERROR_HANDLER.handleError(e);
-                    deliverUncaughtException(e);
-                } finally {
-                    mad.unsubscribe();
+                if (!done) {
+                    done = true;
+                    try {
+                        onComplete.call();
+                    } catch (Throwable e) {
+                        ERROR_HANDLER.handleError(e);
+                        deliverUncaughtException(e);
+                    } finally {
+                        mad.unsubscribe();
+                    }
                 }
             }
             
@@ -1934,20 +1939,34 @@ public final Subscription subscribe(final Action1<? super Throwable> onError, fi
         requireNonNull(onComplete);
         
         final MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
-        subscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new CompletableSubscriber() {
+            boolean done;
             @Override
             public void onCompleted() {
-                try {
-                    onComplete.call();
-                } catch (Throwable e) {
-                    onError(e);
-                    return;
+                if (!done) {
+                    done = true;
+                    try {
+                        onComplete.call();
+                    } catch (Throwable e) {
+                        callOnError(e);
+                        return;
+                    }
+                    mad.unsubscribe();
                 }
-                mad.unsubscribe();
             }
             
             @Override
             public void onError(Throwable e) {
+                if (!done) {
+                    done = true;
+                    callOnError(e);
+                } else {
+                    ERROR_HANDLER.handleError(e);
+                    deliverUncaughtException(e);
+                }
+            }
+            
+            void callOnError(Throwable e) {
                 try {
                     onError.call(e);
                 } catch (Throwable ex) {
@@ -1978,61 +1997,102 @@ private static void deliverUncaughtException(Throwable e) {
      * @param s the CompletableSubscriber, not null
      * @throws NullPointerException if s is null
      */
-    public final void subscribe(CompletableSubscriber s) {
+    public final void unsafeSubscribe(CompletableSubscriber s) {
         requireNonNull(s);
         try {
-            // TODO plugin wrapping the subscriber
+            CompletableOnSubscribe onSubscribeDecorated = HOOK.onSubscribeStart(this, this.onSubscribe);
             
-            onSubscribe.call(s);
+            onSubscribeDecorated.call(s);
         } catch (NullPointerException ex) {
             throw ex;
         } catch (Throwable ex) {
-            ERROR_HANDLER.handleError(ex);
             Exceptions.throwIfFatal(ex);
+            ex = HOOK.onSubscribeError(ex);
+            ERROR_HANDLER.handleError(ex);
             throw toNpe(ex);
         }
     }
 
     /**
-     * Subscribes a reactive-streams Subscriber to this Completable instance which
+     * Subscribes the given CompletableSubscriber to this Completable instance
+     * and handles exceptions thrown by its onXXX methods.
+     * @param s the CompletableSubscriber, not null
+     * @throws NullPointerException if s is null
+     */
+    public final void subscribe(CompletableSubscriber s) {
+        if (!(s instanceof SafeCompletableSubscriber)) {
+            s = new SafeCompletableSubscriber(s);
+        }
+        unsafeSubscribe(s);
+    }
+
+    /**
+     * Subscribes a regular Subscriber to this Completable instance which
      * will receive only an onError or onComplete event.
+     * @param <T> the value type of the subscriber
      * @param s the reactive-streams Subscriber, not null
      * @throws NullPointerException if s is null
      */
-    public final <T> void subscribe(Subscriber<T> s) {
+    public final <T> void unsafeSubscribe(final Subscriber<T> s) {
+        unsafeSubscribe(s, true);
+    }
+
+    /**
+     * Performs the actual unsafe subscription and calls the onStart if required.
+     * @param <T> the value type of the subscriber
+     * @param s the subscriber instance, not null
+     * @param callOnStart if true, the Subscriber.onStart will be called
+     * @throws NullPointerException if s is null
+     */
+    private final <T> void unsafeSubscribe(final Subscriber<T> s, boolean callOnStart) {
         requireNonNull(s);
         try {
-            final Subscriber<?> sw = s; // FIXME hooking in 1.x is kind of strange to me
-            
-            if (sw == null) {
-                throw new NullPointerException("The RxJavaPlugins.onSubscribe returned a null Subscriber");
+            if (callOnStart) {
+                s.onStart();
             }
-            
-            subscribe(new CompletableSubscriber() {
+            unsafeSubscribe(new CompletableSubscriber() {
                 @Override
                 public void onCompleted() {
-                    sw.onCompleted();
+                    s.onCompleted();
                 }
                 
                 @Override
                 public void onError(Throwable e) {
-                    sw.onError(e);
+                    s.onError(e);
                 }
                 
                 @Override
                 public void onSubscribe(Subscription d) {
-                    sw.add(d);
+                    s.add(d);
                 }
             });
-            
+            RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeReturn(s);
         } catch (NullPointerException ex) {
             throw ex;
         } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            ex = HOOK.onSubscribeError(ex);
             ERROR_HANDLER.handleError(ex);
             throw toNpe(ex);
         }
     }
 
+    /**
+     * Subscribes a regular Subscriber to this Completable instance which
+     * will receive only an onError or onComplete event
+     * and handles exceptions thrown by its onXXX methods.
+     * @param <T> the value type of the subscriber
+     * @param s the reactive-streams Subscriber, not null
+     * @throws NullPointerException if s is null
+     */
+    public final <T> void subscribe(Subscriber<T> s) {
+        s.onStart();
+        if (!(s instanceof SafeSubscriber)) {
+            s = new SafeSubscriber<T>(s);
+        }
+        unsafeSubscribe(s, false);
+    }
+
     /**
      * Returns a Completable which subscribes the child subscriber on the specified scheduler, making
      * sure the subscription side-effects happen on that specific thread of the scheduler.
@@ -2054,7 +2114,7 @@ public void call(final CompletableSubscriber s) {
                     @Override
                     public void call() {
                         try {
-                            subscribe(s);
+                            unsafeSubscribe(s);
                         } finally {
                             w.unsubscribe();
                         }
@@ -2157,7 +2217,7 @@ public final <T> Observable<T> toObservable() {
         return Observable.create(new OnSubscribe<T>() {
             @Override
             public void call(Subscriber<? super T> s) {
-                subscribe(s);
+                unsafeSubscribe(s);
             }
         });
     }
@@ -2174,7 +2234,7 @@ public final <T> Single<T> toSingle(final Func0<? extends T> completionValueFunc
         return Single.create(new rx.Single.OnSubscribe<T>() {
             @Override
             public void call(final SingleSubscriber<? super T> s) {
-                subscribe(new CompletableSubscriber() {
+                unsafeSubscribe(new CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
@@ -2238,7 +2298,7 @@ public final Completable unsubscribeOn(final Scheduler scheduler) {
         return create(new CompletableOnSubscribe() {
             @Override
             public void call(final CompletableSubscriber s) {
-                subscribe(new CompletableSubscriber() {
+                unsafeSubscribe(new CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 97c55c0719..2c6bd61646 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -2024,7 +2024,7 @@ public void onSubscribe(Subscription d) {
                 serial.add(main);
                 child.add(serial);
 
-                other.subscribe(so);
+                other.unsafeSubscribe(so);
 
                 return main;
             }
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
index 85d2509264..8b16d7c2f6 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
@@ -130,7 +130,7 @@ void next() {
                 return;
             }
             
-            c.subscribe(inner);
+            c.unsafeSubscribe(inner);
         }
         
         final class ConcatInnerSubscriber implements CompletableSubscriber {
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
index c1f48f61b7..0b132acd43 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
@@ -89,7 +89,7 @@ void next() {
                     return;
                 }
                 
-                a[idx].subscribe(this);
+                a[idx].unsafeSubscribe(this);
             } while (decrementAndGet() != 0);
         }
     }
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
index fe6211153e..0ce11fde78 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
@@ -128,7 +128,7 @@ void next() {
                     return;
                 }
                 
-                c.subscribe(this);
+                c.unsafeSubscribe(this);
             } while (decrementAndGet() != 0);
         }
     }
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
index 651ae49bc1..7309720f1f 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
@@ -101,7 +101,7 @@ public void onNext(Completable t) {
 
             wip.getAndIncrement();
             
-            t.subscribe(new CompletableSubscriber() {
+            t.unsafeSubscribe(new CompletableSubscriber() {
                 Subscription d;
                 boolean innerDone;
                 @Override
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
index 85d3d59b3a..f78c960430 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
@@ -54,7 +54,7 @@ public void call(final CompletableSubscriber s) {
                 }
             }
             
-            c.subscribe(new CompletableSubscriber() {
+            c.unsafeSubscribe(new CompletableSubscriber() {
                 @Override
                 public void onSubscribe(Subscription d) {
                     set.add(d);
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java
index 2a89afbaa2..d98a6a039e 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java
@@ -51,7 +51,7 @@ public void call(final CompletableSubscriber s) {
                 continue;
             }
             
-            c.subscribe(new CompletableSubscriber() {
+            c.unsafeSubscribe(new CompletableSubscriber() {
                 @Override
                 public void onSubscribe(Subscription d) {
                     set.add(d);
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
index be783e6d6d..9d2567135e 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
@@ -117,7 +117,7 @@ public void call(final CompletableSubscriber s) {
             
             wip.getAndIncrement();
             
-            c.subscribe(new CompletableSubscriber() {
+            c.unsafeSubscribe(new CompletableSubscriber() {
                 @Override
                 public void onSubscribe(Subscription d) {
                     set.add(d);
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
index 7ad953e4de..e13670cd20 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
@@ -110,7 +110,7 @@ public void call(final CompletableSubscriber s) {
             
             wip.getAndIncrement();
             
-            c.subscribe(new CompletableSubscriber() {
+            c.unsafeSubscribe(new CompletableSubscriber() {
                 @Override
                 public void onSubscribe(Subscription d) {
                     set.add(d);
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
index 2a9c8e31e2..b62c62274d 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
@@ -60,7 +60,7 @@ public void call() {
                     if (other == null) {
                         s.onError(new TimeoutException());
                     } else {
-                        other.subscribe(new CompletableSubscriber() {
+                        other.unsafeSubscribe(new CompletableSubscriber() {
    
                             @Override
                             public void onSubscribe(Subscription d) {
@@ -85,7 +85,7 @@ public void onCompleted() {
             }
         }, timeout, unit);
         
-        source.subscribe(new CompletableSubscriber() {
+        source.unsafeSubscribe(new CompletableSubscriber() {
 
             @Override
             public void onSubscribe(Subscription d) {
diff --git a/src/main/java/rx/observers/SafeCompletableSubscriber.java b/src/main/java/rx/observers/SafeCompletableSubscriber.java
new file mode 100644
index 0000000000..12258115c7
--- /dev/null
+++ b/src/main/java/rx/observers/SafeCompletableSubscriber.java
@@ -0,0 +1,94 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.observers;
+
+import rx.Completable.CompletableSubscriber;
+import rx.Subscription;
+import rx.annotations.Experimental;
+import rx.exceptions.*;
+import rx.internal.util.RxJavaPluginUtils;
+
+/**
+ * Wraps another CompletableSubscriber and handles exceptions thrown
+ * from onError and onCompleted.
+ * 
+ * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ */
+@Experimental
+public final class SafeCompletableSubscriber implements CompletableSubscriber, Subscription {
+    final CompletableSubscriber actual;
+
+    Subscription s;
+    
+    boolean done;
+    
+    public SafeCompletableSubscriber(CompletableSubscriber actual) {
+        this.actual = actual;
+    }
+
+    @Override
+    public void onCompleted() {
+        if (done) {
+            return;
+        }
+        done = true;
+        try {
+            actual.onCompleted();
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            
+            throw new OnCompletedFailedException(ex);
+        }
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        RxJavaPluginUtils.handleException(e);
+        if (done) {
+            return;
+        }
+        done = true;
+        try {
+            actual.onError(e);
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            
+            throw new OnErrorFailedException(new CompositeException(e, ex));
+        }
+    }
+
+    @Override
+    public void onSubscribe(Subscription d) {
+        this.s = d;
+        try {
+            actual.onSubscribe(this);
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            d.unsubscribe();
+            onError(ex);
+        }
+    }
+    
+    @Override
+    public void unsubscribe() {
+        s.unsubscribe();
+    }
+    
+    @Override
+    public boolean isUnsubscribed() {
+        return done || s.isUnsubscribed();
+    }
+}
diff --git a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
new file mode 100644
index 0000000000..87160f8326
--- /dev/null
+++ b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
@@ -0,0 +1,104 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.plugins;
+
+import rx.*;
+import rx.annotations.Experimental;
+import rx.functions.Func1;
+
+/**
+ * Abstract ExecutionHook with invocations at different lifecycle points of {@link Completable} execution with a
+ * default no-op implementation.
+ * <p>
+ * See {@link RxJavaPlugins} or the RxJava GitHub Wiki for information on configuring plugins:
+ * <a href="https://github.com/ReactiveX/RxJava/wiki/Plugins">https://github.com/ReactiveX/RxJava/wiki/Plugins</a>.
+ * <p>
+ * <b>Note on thread-safety and performance:</b>
+ * <p>
+ * A single implementation of this class will be used globally so methods on this class will be invoked
+ * concurrently from multiple threads so all functionality must be thread-safe.
+ * <p>
+ * Methods are also invoked synchronously and will add to execution time of the completable so all behavior
+ * should be fast. If anything time-consuming is to be done it should be spawned asynchronously onto separate
+ * worker threads.
+ *
+ * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ */
+@Experimental
+public abstract class RxJavaCompletableExecutionHook {
+    /**
+     * Invoked during the construction by {@link Completable#create(Completable.CompletableOnSubscribe)}
+     * <p>
+     * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
+     * logging, metrics and other such things and pass through the function.
+     *
+     * @param f
+     *            original {@link rx.Completable.CompletableOnSubscribe}<{@code T}> to be executed
+     * @return {@link rx.Completable.CompletableOnSubscribe} function that can be modified, decorated, replaced or just
+     *         returned as a pass through
+     */
+    public Completable.CompletableOnSubscribe onCreate(Completable.CompletableOnSubscribe f) {
+        return f;
+    }
+
+    /**
+     * Invoked before {@link Completable#subscribe(Subscriber)} is about to be executed.
+     * <p>
+     * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
+     * logging, metrics and other such things and pass through the function.
+     *
+     * @param completableInstance the target completable instance
+     * @param onSubscribe
+     *            original {@link rx.Completable.CompletableOnSubscribe}<{@code T}> to be executed
+     * @return {@link rx.Completable.CompletableOnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
+     *         returned as a pass through
+     */
+    public Completable.CompletableOnSubscribe onSubscribeStart(Completable completableInstance, final Completable.CompletableOnSubscribe onSubscribe) {
+        // pass through by default
+        return onSubscribe;
+    }
+
+    /**
+     * Invoked after failed execution of {@link Completable#subscribe(Subscriber)} with thrown Throwable.
+     * <p>
+     * This is <em>not</em> errors emitted via {@link Subscriber#onError(Throwable)} but exceptions thrown when
+     * attempting to subscribe to a {@link Func1}<{@link Subscriber}{@code <T>}, {@link Subscription}>.
+     *
+     * @param e
+     *            Throwable thrown by {@link Completable#subscribe(Subscriber)}
+     * @return Throwable that can be decorated, replaced or just returned as a pass through
+     */
+    public Throwable onSubscribeError(Throwable e) {
+        // pass through by default
+        return e;
+    }
+
+    /**
+     * Invoked just as the operator functions is called to bind two operations together into a new
+     * {@link Completable} and the return value is used as the lifted function
+     * <p>
+     * This can be used to decorate or replace the {@link rx.Completable.CompletableOperator} instance or just perform extra
+     * logging, metrics and other such things and pass through the onSubscribe.
+     *
+     * @param lift
+     *            original {@link rx.Completable.CompletableOperator}{@code <R, T>}
+     * @return {@link rx.Completable.CompletableOperator}{@code <R, T>} function that can be modified, decorated, replaced or just
+     *         returned as a pass through
+     */
+    public Completable.CompletableOperator onLift(final Completable.CompletableOperator lift) {
+        return lift;
+    }
+}
diff --git a/src/main/java/rx/plugins/RxJavaPlugins.java b/src/main/java/rx/plugins/RxJavaPlugins.java
index 622916c661..f9926ac588 100644
--- a/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -52,6 +52,7 @@ public class RxJavaPlugins {
     private final AtomicReference<RxJavaErrorHandler> errorHandler = new AtomicReference<RxJavaErrorHandler>();
     private final AtomicReference<RxJavaObservableExecutionHook> observableExecutionHook = new AtomicReference<RxJavaObservableExecutionHook>();
     private final AtomicReference<RxJavaSingleExecutionHook> singleExecutionHook = new AtomicReference<RxJavaSingleExecutionHook>();
+    private final AtomicReference<RxJavaCompletableExecutionHook> completableExecutionHook = new AtomicReference<RxJavaCompletableExecutionHook>();
     private final AtomicReference<RxJavaSchedulersHook> schedulersHook = new AtomicReference<RxJavaSchedulersHook>();
 
     /**
@@ -211,6 +212,52 @@ public void registerSingleExecutionHook(RxJavaSingleExecutionHook impl) {
         }
     }
 
+    /**
+     * Retrieves the instance of {@link RxJavaCompletableExecutionHook} to use based on order of precedence as
+     * defined in {@link RxJavaPlugins} class header.
+     * <p>
+     * Override the default by calling {@link #registerCompletableExecutionHook(RxJavaCompletableExecutionHook)}
+     * or by setting the property {@code rxjava.plugin.RxJavaCompletableExecutionHook.implementation} with the
+     * full classname to load.
+     *
+     * @return {@link RxJavaCompletableExecutionHook} implementation to use
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public RxJavaCompletableExecutionHook getCompletableExecutionHook() {
+        if (completableExecutionHook.get() == null) {
+            // check for an implementation from System.getProperty first
+            Object impl = getPluginImplementationViaProperty(RxJavaCompletableExecutionHook.class, System.getProperties());
+            if (impl == null) {
+                // nothing set via properties so initialize with default
+                completableExecutionHook.compareAndSet(null, new RxJavaCompletableExecutionHook() { });
+                // we don't return from here but call get() again in case of thread-race so the winner will always get returned
+            } else {
+                // we received an implementation from the system property so use it
+                completableExecutionHook.compareAndSet(null, (RxJavaCompletableExecutionHook) impl);
+            }
+        }
+        return completableExecutionHook.get();
+    }
+
+    /**
+     * Register an {@link RxJavaCompletableExecutionHook} implementation as a global override of any injected or
+     * default implementations.
+     *
+     * @param impl
+     *            {@link RxJavaCompletableExecutionHook} implementation
+     * @throws IllegalStateException
+     *             if called more than once or after the default was initialized (if usage occurs before trying
+     *             to register)
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public void registerCompletableExecutionHook(RxJavaCompletableExecutionHook impl) {
+        if (!completableExecutionHook.compareAndSet(null, impl)) {
+            throw new IllegalStateException("Another strategy was already registered: " + singleExecutionHook.get());
+        }
+    }
+
     /* test */ static Object getPluginImplementationViaProperty(Class<?> pluginClass, Properties propsIn) {
         // Make a defensive clone because traversal may fail with ConcurrentModificationException
         // if the properties get changed by something outside RxJava.
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 4f7ce67985..a2a49d6c2d 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -16,6 +16,10 @@
 
 package rx;
 
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
@@ -27,14 +31,11 @@
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.observers.TestSubscriber;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.*;
 import rx.schedulers.*;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.*;
 
-import static org.mockito.Mockito.*;
-import static org.junit.Assert.*;
-
 /**
  * Test Completable methods and operators.
  */
@@ -1159,7 +1160,7 @@ public void call(Long v) {
     public void never() {
         final AtomicBoolean onSubscribeCalled = new AtomicBoolean();
         final AtomicInteger calls = new AtomicInteger();
-        Completable.never().subscribe(new CompletableSubscriber() {
+        Completable.never().unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 onSubscribeCalled.set(true);
@@ -1202,7 +1203,7 @@ public void timerTestScheduler() {
         
         final AtomicInteger calls = new AtomicInteger();
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 
@@ -1235,7 +1236,7 @@ public void timerCancel() throws InterruptedException {
         final MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
         final AtomicInteger calls = new AtomicInteger();
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 mad.set(d);
@@ -1295,7 +1296,7 @@ public void call(Integer d) {
         final AtomicBoolean unsubscribedFirst = new AtomicBoolean();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 
@@ -1341,7 +1342,7 @@ public void call(Integer d) {
         final AtomicBoolean unsubscribedFirst = new AtomicBoolean();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 
@@ -1387,7 +1388,7 @@ public void call(Integer d) {
         final AtomicBoolean unsubscribedFirst = new AtomicBoolean();
         final AtomicBoolean complete = new AtomicBoolean();
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 
@@ -1433,7 +1434,7 @@ public void call(Integer d) {
         final AtomicBoolean unsubscribedFirst = new AtomicBoolean();
         final AtomicBoolean complete = new AtomicBoolean();
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 
@@ -1630,7 +1631,7 @@ public void delayNormal() throws InterruptedException {
         final AtomicBoolean done = new AtomicBoolean();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 
@@ -1665,7 +1666,7 @@ public void delayErrorImmediately() throws InterruptedException {
         final AtomicBoolean done = new AtomicBoolean();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 
@@ -1699,7 +1700,7 @@ public void delayErrorToo() throws InterruptedException {
         final AtomicBoolean done = new AtomicBoolean();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 
@@ -1826,7 +1827,7 @@ public void call() {
             }
         });
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 d.unsubscribe();
@@ -1858,7 +1859,7 @@ public void doOnDisposeThrows() {
             public void call() { throw new TestException(); }
         });
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 d.unsubscribe();
@@ -2017,7 +2018,7 @@ public void call() {
             }
         });
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 
@@ -2173,7 +2174,7 @@ public void observeOnNormal() throws InterruptedException {
         
         Completable c = normal.completable.observeOn(Schedulers.computation());
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 
@@ -2206,7 +2207,7 @@ public void observeOnError() throws InterruptedException {
         
         Completable c = error.completable.observeOn(Schedulers.computation());
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 
@@ -2337,7 +2338,7 @@ public Object call() throws Exception {
             }
         }).repeat();
         
-        c.subscribe(new CompletableSubscriber() {
+        c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(final Subscription d) {
                 final Scheduler.Worker w = Schedulers.io().createWorker();
@@ -2680,19 +2681,19 @@ public void subscribeActionNull() {
     
     @Test(expected = NullPointerException.class)
     public void subscribeSubscriberNull() {
-        normal.completable.subscribe((Subscriber<Object>)null);
+        normal.completable.unsafeSubscribe((Subscriber<Object>)null);
     }
     
     @Test(expected = NullPointerException.class)
     public void subscribeCompletableSubscriberNull() {
-        normal.completable.subscribe((CompletableSubscriber)null);
+        normal.completable.unsafeSubscribe((CompletableSubscriber)null);
     }
 
     @Test(timeout = 1000)
     public void subscribeSubscriberNormal() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
         
-        normal.completable.subscribe(ts);
+        normal.completable.unsafeSubscribe(ts);
         
         ts.assertCompleted();
         ts.assertNoValues();
@@ -2703,7 +2704,7 @@ public void subscribeSubscriberNormal() {
     public void subscribeSubscriberError() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
         
-        error.completable.subscribe(ts);
+        error.completable.unsafeSubscribe(ts);
         
         ts.assertNotCompleted();
         ts.assertNoValues();
@@ -3028,7 +3029,7 @@ public void call() {
             }
         })
         .unsubscribeOn(Schedulers.computation())
-        .subscribe(new CompletableSubscriber() {
+        .unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(final Subscription d) {
                 final Scheduler.Worker w = Schedulers.io().createWorker();
@@ -3628,7 +3629,7 @@ public Integer call() {
             public Completable call(Integer t) {
                 throw new TestException();
             }
-        }, onDispose).subscribe(ts);
+        }, onDispose).unsafeSubscribe(ts);
         
         verify(onDispose).call(1);
         
@@ -3659,7 +3660,7 @@ public Integer call() {
             public Completable call(Integer t) {
                 throw new TestException();
             }
-        }, onDispose).subscribe(ts);
+        }, onDispose).unsafeSubscribe(ts);
         
         ts.assertNoValues();
         ts.assertNotCompleted();
@@ -3693,7 +3694,7 @@ public Integer call() {
             public Completable call(Integer t) {
                 return null;
             }
-        }, onDispose).subscribe(ts);
+        }, onDispose).unsafeSubscribe(ts);
         
         verify(onDispose).call(1);
         
@@ -3724,7 +3725,7 @@ public Integer call() {
             public Completable call(Integer t) {
                 return null;
             }
-        }, onDispose).subscribe(ts);
+        }, onDispose).unsafeSubscribe(ts);
         
         ts.assertNoValues();
         ts.assertNotCompleted();
@@ -3898,4 +3899,217 @@ private static void expectUncaughtTestException(Action0 action) {
         }
     }
 
+    @Test
+    public void safeOnCompleteThrows() {
+        try {
+            normal.completable.subscribe(new CompletableSubscriber() {
+    
+                @Override
+                public void onCompleted() {
+                    throw new TestException("Forced failure");
+                }
+    
+                @Override
+                public void onError(Throwable e) {
+                    
+                }
+    
+                @Override
+                public void onSubscribe(Subscription d) {
+                    
+                }
+                
+            });
+            Assert.fail("Did not propagate exception!");
+        } catch (OnCompletedFailedException ex) {
+            Throwable c = ex.getCause();
+            Assert.assertNotNull(c);
+            
+            Assert.assertEquals("Forced failure", c.getMessage());
+        }
+    }
+
+    @Test
+    public void safeOnCompleteThrowsRegularSubscriber() {
+        try {
+            normal.completable.subscribe(new Subscriber<Object>() {
+    
+                @Override
+                public void onCompleted() {
+                    throw new TestException("Forced failure");
+                }
+    
+                @Override
+                public void onError(Throwable e) {
+                    
+                }
+    
+                @Override
+                public void onNext(Object t) {
+                    
+                }
+            });
+            Assert.fail("Did not propagate exception!");
+        } catch (OnCompletedFailedException ex) {
+            Throwable c = ex.getCause();
+            Assert.assertNotNull(c);
+            
+            Assert.assertEquals("Forced failure", c.getMessage());
+        }
+    }
+
+    @Test
+    public void safeOnErrorThrows() {
+        try {
+            error.completable.subscribe(new CompletableSubscriber() {
+    
+                @Override
+                public void onCompleted() {
+                }
+    
+                @Override
+                public void onError(Throwable e) {
+                    throw new TestException("Forced failure");
+                }
+    
+                @Override
+                public void onSubscribe(Subscription d) {
+                    
+                }
+                
+            });
+            Assert.fail("Did not propagate exception!");
+        } catch (OnErrorFailedException ex) {
+            Throwable c = ex.getCause();
+            Assert.assertTrue("" + c, c instanceof CompositeException);
+            
+            CompositeException ce = (CompositeException)c;
+            
+            List<Throwable> list = ce.getExceptions();
+            
+            Assert.assertEquals(2, list.size());
+
+            Assert.assertTrue("" + list.get(0), list.get(0) instanceof TestException);
+            Assert.assertNull(list.get(0).getMessage());
+
+            Assert.assertTrue("" + list.get(1), list.get(1) instanceof TestException);
+            Assert.assertEquals("Forced failure", list.get(1).getMessage());
+        }
+    }
+
+    @Test
+    public void safeOnErrorThrowsRegularSubscriber() {
+        try {
+            error.completable.subscribe(new Subscriber<Object>() {
+    
+                @Override
+                public void onCompleted() {
+
+                }
+    
+                @Override
+                public void onError(Throwable e) {
+                    throw new TestException("Forced failure");
+                }
+    
+                @Override
+                public void onNext(Object t) {
+                    
+                }
+            });
+            Assert.fail("Did not propagate exception!");
+        } catch (OnErrorFailedException ex) {
+            Throwable c = ex.getCause();
+            Assert.assertTrue("" + c, c instanceof CompositeException);
+            
+            CompositeException ce = (CompositeException)c;
+            
+            List<Throwable> list = ce.getExceptions();
+            
+            Assert.assertEquals(2, list.size());
+
+            Assert.assertTrue("" + list.get(0), list.get(0) instanceof TestException);
+            Assert.assertNull(list.get(0).getMessage());
+
+            Assert.assertTrue("" + list.get(1), list.get(1) instanceof TestException);
+            Assert.assertEquals("Forced failure", list.get(1).getMessage());
+        }
+    }
+
+    private static RxJavaCompletableExecutionHook hookSpy;
+
+    @Before
+    public void setUp() throws Exception {
+        hookSpy = spy(
+                new RxJavaPluginsTest.RxJavaCompletableExecutionHookTestImpl());
+        Completable.HOOK = hookSpy;
+    }
+
+    @Test
+    public void testHookCreate() {
+        CompletableOnSubscribe subscriber = mock(CompletableOnSubscribe.class);
+        Completable.create(subscriber);
+
+        verify(hookSpy, times(1)).onCreate(subscriber);
+    }
+
+    @Test
+    public void testHookSubscribeStart() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+
+        Completable completable = Completable.create(new CompletableOnSubscribe() {
+            @Override public void call(CompletableSubscriber s) {
+                s.onCompleted();
+            }
+        });
+        completable.subscribe(ts);
+
+        verify(hookSpy, times(1)).onSubscribeStart(eq(completable), any(Completable.CompletableOnSubscribe.class));
+    }
+
+    @Test
+    public void testHookUnsafeSubscribeStart() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+        Completable completable = Completable.create(new CompletableOnSubscribe() {
+            @Override public void call(CompletableSubscriber s) {
+                s.onCompleted();
+            }
+        });
+        completable.unsafeSubscribe(ts);
+
+        verify(hookSpy, times(1)).onSubscribeStart(eq(completable), any(Completable.CompletableOnSubscribe.class));
+    }
+
+    @Test
+    public void onStartCalledSafe() {
+        TestSubscriber<Object> ts = new TestSubscriber<Object>() {
+            @Override
+            public void onStart() {
+                onNext(1);
+            }
+        };
+        
+        normal.completable.subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void onStartCalledUnsafeSafe() {
+        TestSubscriber<Object> ts = new TestSubscriber<Object>() {
+            @Override
+            public void onStart() {
+                onNext(1);
+            }
+        };
+        
+        normal.completable.unsafeSubscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index fca462407b..12b059e648 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -821,7 +821,7 @@ public void testToObservable() {
     public void toCompletableSuccess() {
         Completable completable = Single.just("value").toCompletable();
         TestSubscriber<Object> testSubscriber = new TestSubscriber<Object>();
-        completable.subscribe(testSubscriber);
+        completable.unsafeSubscribe(testSubscriber);
 
         testSubscriber.assertCompleted();
         testSubscriber.assertNoValues();
@@ -833,7 +833,7 @@ public void toCompletableError() {
         TestException exception = new TestException();
         Completable completable = Single.error(exception).toCompletable();
         TestSubscriber<Object> testSubscriber = new TestSubscriber<Object>();
-        completable.subscribe(testSubscriber);
+        completable.unsafeSubscribe(testSubscriber);
 
         testSubscriber.assertError(exception);
         testSubscriber.assertNoValues();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeCompletableTest.java b/src/test/java/rx/internal/operators/OnSubscribeCompletableTest.java
index e30bb78062..8cad9c96b6 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeCompletableTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeCompletableTest.java
@@ -32,7 +32,7 @@ public class OnSubscribeCompletableTest {
     public void testJustSingleItemObservable() {
         TestSubscriber<String> subscriber = TestSubscriber.create();
         Completable cmp = Observable.just("Hello World!").toCompletable();
-        cmp.subscribe(subscriber);
+        cmp.unsafeSubscribe(subscriber);
 
         subscriber.assertNoValues();
         subscriber.assertCompleted();
@@ -44,7 +44,7 @@ public void testErrorObservable() {
         TestSubscriber<String> subscriber = TestSubscriber.create();
         IllegalArgumentException error = new IllegalArgumentException("Error");
         Completable cmp = Observable.<String>error(error).toCompletable();
-        cmp.subscribe(subscriber);
+        cmp.unsafeSubscribe(subscriber);
 
         subscriber.assertError(error);
         subscriber.assertNoValues();
@@ -54,7 +54,7 @@ public void testErrorObservable() {
     public void testJustTwoEmissionsObservableThrowsError() {
         TestSubscriber<String> subscriber = TestSubscriber.create();
         Completable cmp = Observable.just("First", "Second").toCompletable();
-        cmp.subscribe(subscriber);
+        cmp.unsafeSubscribe(subscriber);
 
         subscriber.assertNoErrors();
         subscriber.assertNoValues();
@@ -64,7 +64,7 @@ public void testJustTwoEmissionsObservableThrowsError() {
     public void testEmptyObservable() {
         TestSubscriber<String> subscriber = TestSubscriber.create();
         Completable cmp = Observable.<String>empty().toCompletable();
-        cmp.subscribe(subscriber);
+        cmp.unsafeSubscribe(subscriber);
 
         subscriber.assertNoErrors();
         subscriber.assertNoValues();
@@ -75,7 +75,7 @@ public void testEmptyObservable() {
     public void testNeverObservable() {
         TestSubscriber<String> subscriber = TestSubscriber.create();
         Completable cmp = Observable.<String>never().toCompletable();
-        cmp.subscribe(subscriber);
+        cmp.unsafeSubscribe(subscriber);
 
         subscriber.assertNoTerminalEvent();
         subscriber.assertNoValues();
@@ -91,7 +91,7 @@ public void testShouldUseUnsafeSubscribeInternallyNotSubscribe() {
             public void call() {
                 unsubscribed.set(true);
             }}).toCompletable();
-        cmp.subscribe(subscriber);
+        cmp.unsafeSubscribe(subscriber);
         subscriber.assertCompleted();
         assertFalse(unsubscribed.get());
     }
diff --git a/src/test/java/rx/plugins/RxJavaPluginsTest.java b/src/test/java/rx/plugins/RxJavaPluginsTest.java
index 64a1ba1d1a..9c471cfa9c 100644
--- a/src/test/java/rx/plugins/RxJavaPluginsTest.java
+++ b/src/test/java/rx/plugins/RxJavaPluginsTest.java
@@ -23,8 +23,8 @@
 
 import org.junit.*;
 
+import rx.*;
 import rx.Observable;
-import rx.Subscriber;
 import rx.exceptions.OnErrorThrowable;
 import rx.functions.Func1;
 
@@ -253,6 +253,11 @@ public static class RxJavaSingleExecutionHookTestImpl extends RxJavaSingleExecut
         // just use defaults
     }
 
+    // inside test so it is stripped from Javadocs
+    public static class RxJavaCompletableExecutionHookTestImpl extends RxJavaCompletableExecutionHook {
+        // just use defaults
+    }
+
     private static String getFullClassNameForTestClass(Class<?> cls) {
         return RxJavaPlugins.class.getPackage()
                                   .getName() + "." + RxJavaPluginsTest.class.getSimpleName() + "$" + cls.getSimpleName();
@@ -286,4 +291,56 @@ public void testShortPluginDiscoveryMissing() {
 
         RxJavaPlugins.getPluginImplementationViaProperty(Map.class, props);
     }
+
+    @Test
+    public void testOnErrorWhenUsingCompletable() {
+        RxJavaErrorHandlerTestImpl errorHandler = new RxJavaErrorHandlerTestImpl();
+           RxJavaPlugins.getInstance().registerErrorHandler(errorHandler);
+
+        RuntimeException re = new RuntimeException("test onError");
+        Completable.error(re).subscribe(new Subscriber<Object>() {
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+
+            }
+
+            @Override
+            public void onNext(Object o) {
+
+            }
+        });
+        assertEquals(re, errorHandler.e);
+        assertEquals(1, errorHandler.count);
+    }
+
+    @Test
+    public void testOnErrorWhenUsingSingle() {
+        RxJavaErrorHandlerTestImpl errorHandler = new RxJavaErrorHandlerTestImpl();
+        RxJavaPlugins.getInstance().registerErrorHandler(errorHandler);
+
+        RuntimeException re = new RuntimeException("test onError");
+        Single.error(re).subscribe(new Subscriber<Object>() {
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+
+            }
+
+            @Override
+            public void onNext(Object o) {
+
+            }
+        });
+        assertEquals(re, errorHandler.e);
+        assertEquals(1, errorHandler.count);
+    }
 }

From ab6dbc1d68c92c81d4db52866052425125e865c2 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 1 Jun 2016 21:08:25 +0200
Subject: [PATCH 039/263] 1.x: remove remaining field updaters (#3979)

This PR removes the remaining AtomicXFieldUpdaters from the library because reflection is somewhat problematic on Android.

This also deprecates the internal BackpressureUtils.getAndAddRequest to indicate requested field updater should not be used anymore.
---
 .../internal/operators/BackpressureUtils.java |  2 +
 .../CompletableOnSubscribeConcat.java         |  9 +-
 .../CompletableOnSubscribeMerge.java          | 25 +++--
 .../internal/operators/OperatorGroupBy.java   | 97 ++++++++-----------
 .../schedulers/CachedThreadScheduler.java     |  8 +-
 .../atomic/SpscExactAtomicArrayQueue.java     | 31 +++---
 .../atomic/SpscUnboundedAtomicArrayQueue.java | 24 ++---
 .../java/rx/observables/AsyncOnSubscribe.java | 15 ++-
 8 files changed, 90 insertions(+), 121 deletions(-)

diff --git a/src/main/java/rx/internal/operators/BackpressureUtils.java b/src/main/java/rx/internal/operators/BackpressureUtils.java
index 4a2fa90f48..6a13709649 100644
--- a/src/main/java/rx/internal/operators/BackpressureUtils.java
+++ b/src/main/java/rx/internal/operators/BackpressureUtils.java
@@ -45,7 +45,9 @@ private BackpressureUtils() {
      * @param n
      *            the number of requests to add to the requested count
      * @return requested value just prior to successful addition
+     * @deprecated Android has issues with reflection-based atomics
      */
+    @Deprecated
     public static <T> long getAndAddRequest(AtomicLongFieldUpdater<T> requested, T object, long n) {
         // add n to field but check for overflow
         while (true) {
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
index 8b16d7c2f6..bccea15cc4 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
@@ -52,9 +52,7 @@ static final class CompletableConcatSubscriber
         
         volatile boolean done;
 
-        volatile int once;
-        static final AtomicIntegerFieldUpdater<CompletableConcatSubscriber> ONCE =
-                AtomicIntegerFieldUpdater.newUpdater(CompletableConcatSubscriber.class, "once");
+        final AtomicBoolean once;
         
         final ConcatInnerSubscriber inner;
         
@@ -67,6 +65,7 @@ public CompletableConcatSubscriber(CompletableSubscriber actual, int prefetch) {
             this.sr = new SerialSubscription();
             this.inner = new ConcatInnerSubscriber();
             this.wip = new AtomicInteger();
+            this.once = new AtomicBoolean();
             add(sr);
             request(prefetch);
         }
@@ -84,7 +83,7 @@ public void onNext(Completable t) {
         
         @Override
         public void onError(Throwable t) {
-            if (ONCE.compareAndSet(this, 0, 1)) {
+            if (once.compareAndSet(false, true)) {
                 actual.onError(t);
                 return;
             }
@@ -121,7 +120,7 @@ void next() {
             Completable c = queue.poll();
             if (c == null) {
                 if (d) {
-                    if (ONCE.compareAndSet(this, 0, 1)) {
+                    if (once.compareAndSet(false, true)) {
                         actual.onCompleted();
                     }
                     return;
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
index 7309720f1f..059e193da7 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
@@ -55,14 +55,9 @@ static final class CompletableMergeSubscriber
         
         volatile boolean done;
         
-        volatile Queue<Throwable> errors;
-        @SuppressWarnings("rawtypes")
-        static final AtomicReferenceFieldUpdater<CompletableMergeSubscriber, Queue> ERRORS =
-                AtomicReferenceFieldUpdater.newUpdater(CompletableMergeSubscriber.class, Queue.class, "errors");
+        final AtomicReference<Queue<Throwable>> errors;
         
-        volatile int once;
-        static final AtomicIntegerFieldUpdater<CompletableMergeSubscriber> ONCE =
-                AtomicIntegerFieldUpdater.newUpdater(CompletableMergeSubscriber.class, "once");
+        final AtomicBoolean once;
         
         final AtomicInteger wip;
         
@@ -72,6 +67,8 @@ public CompletableMergeSubscriber(CompletableSubscriber actual, int maxConcurren
             this.delayErrors = delayErrors;
             this.set = new CompositeSubscription();
             this.wip = new AtomicInteger(1);
+            this.once = new AtomicBoolean();
+            this.errors = new AtomicReference<Queue<Throwable>>();
             if (maxConcurrency == Integer.MAX_VALUE) {
                 request(Long.MAX_VALUE);
             } else {
@@ -80,17 +77,17 @@ public CompletableMergeSubscriber(CompletableSubscriber actual, int maxConcurren
         }
         
         Queue<Throwable> getOrCreateErrors() {
-            Queue<Throwable> q = errors;
+            Queue<Throwable> q = errors.get();
             
             if (q != null) {
                 return q;
             }
             
             q = new ConcurrentLinkedQueue<Throwable>();
-            if (ERRORS.compareAndSet(this, null, q)) {
+            if (errors.compareAndSet(null, q)) {
                 return q;
             }
-            return errors;
+            return errors.get();
         }
 
         @Override
@@ -167,12 +164,12 @@ public void onCompleted() {
 
         void terminate() {
             if (wip.decrementAndGet() == 0) {
-                Queue<Throwable> q = errors;
+                Queue<Throwable> q = errors.get();
                 if (q == null || q.isEmpty()) {
                     actual.onCompleted();
                 } else {
                     Throwable e = collectErrors(q);
-                    if (ONCE.compareAndSet(this, 0, 1)) {
+                    if (once.compareAndSet(false, true)) {
                         actual.onError(e);
                     } else {
                         RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
@@ -180,10 +177,10 @@ void terminate() {
                 }
             } else
             if (!delayErrors) {
-                Queue<Throwable> q = errors;
+                Queue<Throwable> q = errors.get();
                 if (q != null && !q.isEmpty()) {
                     Throwable e = collectErrors(q);
-                    if (ONCE.compareAndSet(this, 0, 1)) {
+                    if (once.compareAndSet(false, true)) {
                         actual.onError(e);
                     } else {
                         RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index 05fbd6445f..bf474619bb 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -106,28 +106,16 @@ public static final class GroupBySubscriber<T, K, V>
         
         final ProducerArbiter s;
         
-        volatile int cancelled;
-        @SuppressWarnings("rawtypes")
-        static final AtomicIntegerFieldUpdater<GroupBySubscriber> CANCELLED =
-                AtomicIntegerFieldUpdater.newUpdater(GroupBySubscriber.class, "cancelled");
+        final AtomicBoolean cancelled;
 
-        volatile long requested;
-        @SuppressWarnings("rawtypes")
-        static final AtomicLongFieldUpdater<GroupBySubscriber> REQUESTED =
-                AtomicLongFieldUpdater.newUpdater(GroupBySubscriber.class, "requested");
-        
-        volatile int groupCount;
-        @SuppressWarnings("rawtypes")
-        static final AtomicIntegerFieldUpdater<GroupBySubscriber> GROUP_COUNT =
-                AtomicIntegerFieldUpdater.newUpdater(GroupBySubscriber.class, "groupCount");
+        final AtomicLong requested;
+
+        final AtomicInteger groupCount;
         
         Throwable error;
         volatile boolean done;
 
-        volatile int wip;
-        @SuppressWarnings("rawtypes")
-        static final AtomicIntegerFieldUpdater<GroupBySubscriber> WIP =
-                AtomicIntegerFieldUpdater.newUpdater(GroupBySubscriber.class, "wip");
+        final AtomicInteger wip;
         
         public GroupBySubscriber(Subscriber<? super GroupedObservable<K, V>> actual, Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError) {
             this.actual = actual;
@@ -137,10 +125,13 @@ public GroupBySubscriber(Subscriber<? super GroupedObservable<K, V>> actual, Fun
             this.delayError = delayError;
             this.groups = new ConcurrentHashMap<Object, GroupedUnicast<K, V>>();
             this.queue = new ConcurrentLinkedQueue<GroupedObservable<K, V>>();
-            GROUP_COUNT.lazySet(this, 1);
             this.s = new ProducerArbiter();
             this.s.request(bufferSize);
             this.producer = new GroupByProducer(this);
+            this.cancelled = new AtomicBoolean();
+            this.requested = new AtomicLong();
+            this.groupCount = new AtomicInteger(1);
+            this.wip = new AtomicInteger();
         }
         
         @Override
@@ -172,11 +163,11 @@ public void onNext(T t) {
             if (group == null) {
                 // if the main has been cancelled, stop creating groups
                 // and skip this value
-                if (cancelled == 0) {
+                if (!cancelled.get()) {
                     group = GroupedUnicast.createWith(key, bufferSize, this, delayError);
                     groups.put(mapKey, group);
                     
-                    GROUP_COUNT.getAndIncrement(this);
+                    groupCount.getAndIncrement();
                     
                     notNew = false;
                     q.offer(group);
@@ -210,7 +201,7 @@ public void onError(Throwable t) {
             }
             error = t;
             done = true;
-            GROUP_COUNT.decrementAndGet(this);
+            groupCount.decrementAndGet();
             drain();
         }
         
@@ -226,7 +217,7 @@ public void onCompleted() {
             groups.clear();
 
             done = true;
-            GROUP_COUNT.decrementAndGet(this);
+            groupCount.decrementAndGet();
             drain();
         }
 
@@ -235,15 +226,15 @@ public void requestMore(long n) {
                 throw new IllegalArgumentException("n >= 0 required but it was " + n);
             }
             
-            BackpressureUtils.getAndAddRequest(REQUESTED, this, n);
+            BackpressureUtils.getAndAddRequest(requested, n);
             drain();
         }
         
         public void cancel() {
             // cancelling the main source means we don't want any more groups
             // but running groups still require new values
-            if (CANCELLED.compareAndSet(this, 0, 1)) {
-                if (GROUP_COUNT.decrementAndGet(this) == 0) {
+            if (cancelled.compareAndSet(false, true)) {
+                if (groupCount.decrementAndGet() == 0) {
                     unsubscribe();
                 }
             }
@@ -252,14 +243,14 @@ public void cancel() {
         public void cancel(K key) {
             Object mapKey = key != null ? key : NULL_KEY;
             if (groups.remove(mapKey) != null) {
-                if (GROUP_COUNT.decrementAndGet(this) == 0) {
+                if (groupCount.decrementAndGet() == 0) {
                     unsubscribe();
                 }
             }
         }
         
         void drain() {
-            if (WIP.getAndIncrement(this) != 0) {
+            if (wip.getAndIncrement() != 0) {
                 return;
             }
             
@@ -274,7 +265,7 @@ void drain() {
                     return;
                 }
                 
-                long r = requested;
+                long r = requested.get();
                 boolean unbounded = r == Long.MAX_VALUE;
                 long e = 0L;
                 
@@ -301,12 +292,12 @@ void drain() {
                 
                 if (e != 0L) {
                     if (!unbounded) {
-                        REQUESTED.addAndGet(this, e);
+                        requested.addAndGet(e);
                     }
                     s.request(-e);
                 }
                 
-                missed = WIP.addAndGet(this, -missed);
+                missed = wip.addAndGet(-missed);
                 if (missed == 0) {
                     break;
                 }
@@ -378,28 +369,16 @@ static final class State<T, K> extends AtomicInteger implements Producer, Subscr
         final GroupBySubscriber<?, K, T> parent;
         final boolean delayError;
         
-        volatile long requested;
-        @SuppressWarnings("rawtypes")
-        static final AtomicLongFieldUpdater<State> REQUESTED =
-                AtomicLongFieldUpdater.newUpdater(State.class, "requested");
+        final AtomicLong requested;
         
         volatile boolean done;
         Throwable error;
         
-        volatile int cancelled;
-        @SuppressWarnings("rawtypes")
-        static final AtomicIntegerFieldUpdater<State> CANCELLED =
-                AtomicIntegerFieldUpdater.newUpdater(State.class, "cancelled");
-        
-        volatile Subscriber<? super T> actual;
-        @SuppressWarnings("rawtypes")
-        static final AtomicReferenceFieldUpdater<State, Subscriber> ACTUAL =
-                AtomicReferenceFieldUpdater.newUpdater(State.class, Subscriber.class, "actual");
+        final AtomicBoolean cancelled;
+
+        final AtomicReference<Subscriber<? super T>> actual;
 
-        volatile int once;
-        @SuppressWarnings("rawtypes")
-        static final AtomicIntegerFieldUpdater<State> ONCE =
-                AtomicIntegerFieldUpdater.newUpdater(State.class, "once");
+        final AtomicBoolean once;
 
         
         public State(int bufferSize, GroupBySubscriber<?, K, T> parent, K key, boolean delayError) {
@@ -407,6 +386,10 @@ public State(int bufferSize, GroupBySubscriber<?, K, T> parent, K key, boolean d
             this.parent = parent;
             this.key = key;
             this.delayError = delayError;
+            this.cancelled = new AtomicBoolean();
+            this.actual = new AtomicReference<Subscriber<? super T>>();
+            this.once = new AtomicBoolean();
+            this.requested = new AtomicLong();
         }
         
         @Override
@@ -415,19 +398,19 @@ public void request(long n) {
                 throw new IllegalArgumentException("n >= required but it was " + n);
             }
             if (n != 0L) {
-                BackpressureUtils.getAndAddRequest(REQUESTED, this, n);
+                BackpressureUtils.getAndAddRequest(requested, n);
                 drain();
             }
         }
         
         @Override
         public boolean isUnsubscribed() {
-            return cancelled != 0;
+            return cancelled.get();
         }
         
         @Override
         public void unsubscribe() {
-            if (CANCELLED.compareAndSet(this, 0, 1)) {
+            if (cancelled.compareAndSet(false, true)) {
                 if (getAndIncrement() == 0) {
                     parent.cancel(key);
                 }
@@ -436,10 +419,10 @@ public void unsubscribe() {
         
         @Override
         public void call(Subscriber<? super T> s) {
-            if (ONCE.compareAndSet(this, 0, 1)) {
+            if (once.compareAndSet(false, true)) {
                 s.add(this);
                 s.setProducer(this);
-                ACTUAL.lazySet(this, s);
+                actual.lazySet(s);
                 drain();
             } else {
                 s.onError(new IllegalStateException("Only one Subscriber allowed!"));
@@ -475,7 +458,7 @@ void drain() {
             
             final Queue<Object> q = queue;
             final boolean delayError = this.delayError;
-            Subscriber<? super T> a = actual;
+            Subscriber<? super T> a = actual.get();
             NotificationLite<T> nl = NotificationLite.instance();
             for (;;) {
                 if (a != null) {
@@ -483,7 +466,7 @@ void drain() {
                         return;
                     }
                     
-                    long r = requested;
+                    long r = requested.get();
                     boolean unbounded = r == Long.MAX_VALUE;
                     long e = 0;
                     
@@ -508,7 +491,7 @@ void drain() {
                     
                     if (e != 0L) {
                         if (!unbounded) {
-                            REQUESTED.addAndGet(this, e);
+                            requested.addAndGet(e);
                         }
                         parent.s.request(-e);
                     }
@@ -519,13 +502,13 @@ void drain() {
                     break;
                 }
                 if (a == null) {
-                    a = actual;
+                    a = actual.get();
                 }
             }
         }
         
         boolean checkTerminated(boolean d, boolean empty, Subscriber<? super T> a, boolean delayError) {
-            if (cancelled != 0) {
+            if (cancelled.get()) {
                 queue.clear();
                 parent.cancel(key);
                 return true;
diff --git a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
index 1ebfa56fe4..c1655f0aa3 100644
--- a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
+++ b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
@@ -177,19 +177,17 @@ private static final class EventLoopWorker extends Scheduler.Worker {
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
         private final CachedWorkerPool pool;
         private final ThreadWorker threadWorker;
-        @SuppressWarnings("unused")
-        volatile int once;
-        static final AtomicIntegerFieldUpdater<EventLoopWorker> ONCE_UPDATER
-                = AtomicIntegerFieldUpdater.newUpdater(EventLoopWorker.class, "once");
+        final AtomicBoolean once;
 
         EventLoopWorker(CachedWorkerPool pool) {
             this.pool = pool;
+            this.once = new AtomicBoolean();
             this.threadWorker = pool.get();
         }
 
         @Override
         public void unsubscribe() {
-            if (ONCE_UPDATER.compareAndSet(this, 0, 1)) {
+            if (once.compareAndSet(false, true)) {
                 // unsubscribe should be idempotent, so only do this once
                 pool.release(threadWorker);
             }
diff --git a/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
index 1151a7a3a9..53f9b719ce 100644
--- a/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
@@ -33,21 +33,16 @@ public final class SpscExactAtomicArrayQueue<T> extends AtomicReferenceArray<T>
     private static final long serialVersionUID = 6210984603741293445L;
     final int mask;
     final int capacitySkip;
-    volatile long producerIndex;
-    volatile long consumerIndex;
-
-    @SuppressWarnings("rawtypes")
-    static final AtomicLongFieldUpdater<SpscExactAtomicArrayQueue> PRODUCER_INDEX =
-            AtomicLongFieldUpdater.newUpdater(SpscExactAtomicArrayQueue.class, "producerIndex");
-    @SuppressWarnings("rawtypes")
-    static final AtomicLongFieldUpdater<SpscExactAtomicArrayQueue> CONSUMER_INDEX =
-            AtomicLongFieldUpdater.newUpdater(SpscExactAtomicArrayQueue.class, "consumerIndex");
+    final AtomicLong producerIndex;
+    final AtomicLong consumerIndex;
     
     public SpscExactAtomicArrayQueue(int capacity) {
         super(Pow2.roundToPowerOfTwo(capacity));
         int len = length();
         this.mask = len - 1;
-        this.capacitySkip = len - capacity; 
+        this.capacitySkip = len - capacity;
+        this.producerIndex = new AtomicLong();
+        this.consumerIndex = new AtomicLong();
     }
     
     
@@ -57,7 +52,7 @@ public boolean offer(T value) {
             throw new NullPointerException();
         }
         
-        long pi = producerIndex;
+        long pi = producerIndex.get();
         int m = mask;
         
         int fullCheck = (int)(pi + capacitySkip) & m;
@@ -65,25 +60,25 @@ public boolean offer(T value) {
             return false;
         }
         int offset = (int)pi & m;
-        PRODUCER_INDEX.lazySet(this, pi + 1);
+        producerIndex.lazySet(pi + 1);
         lazySet(offset, value);
         return true;
     }
     @Override
     public T poll() {
-        long ci = consumerIndex;
+        long ci = consumerIndex.get();
         int offset = (int)ci & mask;
         T value = get(offset);
         if (value == null) {
             return null;
         }
-        CONSUMER_INDEX.lazySet(this, ci + 1);
+        consumerIndex.lazySet(ci + 1);
         lazySet(offset, null);
         return value;
     }
     @Override
     public T peek() {
-        return get((int)consumerIndex & mask);
+        return get((int)consumerIndex.get() & mask);
     }
     @Override
     public void clear() {
@@ -96,10 +91,10 @@ public boolean isEmpty() {
     
     @Override
     public int size() {
-        long ci = consumerIndex;
+        long ci = consumerIndex.get();
         for (;;) {
-            long pi = producerIndex;
-            long ci2 = consumerIndex;
+            long pi = producerIndex.get();
+            long ci2 = consumerIndex.get();
             if (ci == ci2) {
                 return (int)(pi - ci2);
             }
diff --git a/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
index 36bba49862..728591794e 100644
--- a/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
@@ -32,25 +32,21 @@
  */
 public final class SpscUnboundedAtomicArrayQueue<T> implements Queue<T> {
     static final int MAX_LOOK_AHEAD_STEP = Integer.getInteger("jctools.spsc.max.lookahead.step", 4096);
-    protected volatile long producerIndex;
-    @SuppressWarnings("rawtypes")
-    static final AtomicLongFieldUpdater<SpscUnboundedAtomicArrayQueue> PRODUCER_INDEX =
-            AtomicLongFieldUpdater.newUpdater(SpscUnboundedAtomicArrayQueue.class, "producerIndex");
+    final AtomicLong producerIndex;
     protected int producerLookAheadStep;
     protected long producerLookAhead;
     protected int producerMask;
     protected AtomicReferenceArray<Object> producerBuffer;
     protected int consumerMask;
     protected AtomicReferenceArray<Object> consumerBuffer;
-    protected volatile long consumerIndex;
-    @SuppressWarnings("rawtypes")
-    static final AtomicLongFieldUpdater<SpscUnboundedAtomicArrayQueue> CONSUMER_INDEX =
-            AtomicLongFieldUpdater.newUpdater(SpscUnboundedAtomicArrayQueue.class, "consumerIndex");
+    final AtomicLong consumerIndex;
     private static final Object HAS_NEXT = new Object();
 
     public SpscUnboundedAtomicArrayQueue(final int bufferSize) {
         int p2capacity = Pow2.roundToPowerOfTwo(Math.max(8, bufferSize)); // lookahead doesn't work with capacity < 8
         int mask = p2capacity - 1;
+        this.producerIndex = new AtomicLong();
+        this.consumerIndex = new AtomicLong();
         AtomicReferenceArray<Object> buffer = new AtomicReferenceArray<Object>(p2capacity + 1);
         producerBuffer = buffer;
         producerMask = mask;
@@ -221,27 +217,27 @@ private void adjustLookAheadStep(int capacity) {
     }
 
     private long lvProducerIndex() {
-        return producerIndex;
+        return producerIndex.get();
     }
 
     private long lvConsumerIndex() {
-        return consumerIndex;
+        return consumerIndex.get();
     }
 
     private long lpProducerIndex() {
-        return producerIndex;
+        return producerIndex.get();
     }
 
     private long lpConsumerIndex() {
-        return consumerIndex;
+        return consumerIndex.get();
     }
 
     private void soProducerIndex(long v) {
-        PRODUCER_INDEX.lazySet(this, v);
+        producerIndex.lazySet(v);
     }
 
     private void soConsumerIndex(long v) {
-        CONSUMER_INDEX.lazySet(this, v);
+        consumerIndex.lazySet(v);
     }
 
     private static int calcWrappedOffset(long index, int mask) {
diff --git a/src/main/java/rx/observables/AsyncOnSubscribe.java b/src/main/java/rx/observables/AsyncOnSubscribe.java
index 56b963429e..9b8926622f 100644
--- a/src/main/java/rx/observables/AsyncOnSubscribe.java
+++ b/src/main/java/rx/observables/AsyncOnSubscribe.java
@@ -17,7 +17,7 @@
 package rx.observables;
 
 import java.util.*;
-import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.*;
 import rx.Observable;
@@ -25,8 +25,8 @@
 import rx.Observer;
 import rx.annotations.Experimental;
 import rx.functions.*;
-import rx.internal.operators.*;
-import rx.observers.*;
+import rx.internal.operators.BufferUntilSubscriber;
+import rx.observers.SerializedObserver;
 import rx.plugins.RxJavaPlugins;
 import rx.subscriptions.CompositeSubscription;
 
@@ -359,9 +359,7 @@ public Observable<T> call(Observable<T> v) {
 
     static final class AsyncOuterManager<S, T> implements Producer, Subscription, Observer<Observable<? extends T>> {
 
-        private volatile int isUnsubscribed;
-        @SuppressWarnings("rawtypes")
-        private static final AtomicIntegerFieldUpdater<AsyncOuterManager> IS_UNSUBSCRIBED = AtomicIntegerFieldUpdater.newUpdater(AsyncOuterManager.class, "isUnsubscribed");
+        final AtomicBoolean isUnsubscribed;
 
         private final AsyncOnSubscribe<S, T> parent;
         private final SerializedObserver<Observable<? extends T>> serializedSubscriber;
@@ -385,11 +383,12 @@ public AsyncOuterManager(AsyncOnSubscribe<S, T> parent, S initialState, UnicastS
             this.serializedSubscriber = new SerializedObserver<Observable<? extends T>>(this);
             this.state = initialState;
             this.merger = merger;
+            this.isUnsubscribed = new AtomicBoolean();
         }
 
         @Override
         public void unsubscribe() {
-            if (IS_UNSUBSCRIBED.compareAndSet(this, 0, 1)) {
+            if (isUnsubscribed.compareAndSet(false, true)) {
                 synchronized (this) {
                     if (emitting) {
                         requests = new ArrayList<Long>();
@@ -411,7 +410,7 @@ void setConcatProducer(Producer p) {
         
         @Override
         public boolean isUnsubscribed() {
-            return isUnsubscribed != 0;
+            return isUnsubscribed.get();
         }
 
         public void nextIteration(long requestCount) {

From bc83db0684d33b931ea966b804d1c9b488792cd8 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 1 Jun 2016 23:53:27 +0200
Subject: [PATCH 040/263] 1.x: request rebatch operator (#3971)

* 1.x: request rebatch operator

* Add argument test

* Fix javadoc, add experimental
---
 src/main/java/rx/Observable.java              | 26 +++++++++++++++
 .../internal/operators/OperatorObserveOn.java | 12 +++++++
 .../operators/OperatorObserveOnTest.java      | 33 +++++++++++++++++++
 3 files changed, 71 insertions(+)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index cf2149bc6d..48d2f3adc6 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -6698,6 +6698,32 @@ public final <R> Observable<R> publish(Func1<? super Observable<T>, ? extends Ob
         return OperatorPublish.create(this, selector);
     }
 
+    /**
+     * Requests {@code n} initially from the upstream and then 75% of {@code n} subsequently
+     * after 75% of {@code n} values have been emitted to the downstream.
+     * 
+     * <p>This operator allows preventing the downstream to trigger unbounded mode via {@code request(Long.MAX_VALUE)}
+     * or compensate for the per-item overhead of small and frequent requests.
+     * 
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator expects backpressure from upstream and honors backpressure from downstream.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code rebatchRequests} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *  
+     * @param n the initial request amount, further request will happen after 75% of this value
+     * @return the Observable that rebatches request amounts from downstream
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final Observable<T> rebatchRequests(int n) {
+        if (n <= 0) {
+            throw new IllegalArgumentException("n > 0 required but it was " + n);
+        }
+        return lift(OperatorObserveOn.<T>rebatch(n));
+    }
+    
     /**
      * Returns an Observable that applies a specified accumulator function to the first item emitted by a source
      * Observable, then feeds the result of that function along with the second item emitted by the source
diff --git a/src/main/java/rx/internal/operators/OperatorObserveOn.java b/src/main/java/rx/internal/operators/OperatorObserveOn.java
index f09a424020..10ad74e4e2 100644
--- a/src/main/java/rx/internal/operators/OperatorObserveOn.java
+++ b/src/main/java/rx/internal/operators/OperatorObserveOn.java
@@ -27,6 +27,7 @@
 import rx.internal.util.atomic.SpscAtomicArrayQueue;
 import rx.internal.util.unsafe.*;
 import rx.plugins.RxJavaPlugins;
+import rx.schedulers.Schedulers;
 
 /**
  * Delivers events on the specified {@code Scheduler} asynchronously via an unbounded buffer.
@@ -75,6 +76,17 @@ public Subscriber<? super T> call(Subscriber<? super T> child) {
             return parent;
         }
     }
+    
+    public static <T> Operator<T, T> rebatch(final int n) {
+        return new Operator<T, T>() {
+            @Override
+            public Subscriber<? super T> call(Subscriber<? super T> child) {
+                ObserveOnSubscriber<T> parent = new ObserveOnSubscriber<T>(Schedulers.immediate(), child, false, n);
+                parent.init();
+                return parent;
+            }
+        };
+    }
 
     /** Observe through individual queue per observer. */
     private static final class ObserveOnSubscriber<T> extends Subscriber<T> implements Action0 {
diff --git a/src/test/java/rx/internal/operators/OperatorObserveOnTest.java b/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
index 6e066c19ad..ef5ab6d332 100644
--- a/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
@@ -933,4 +933,37 @@ public void bufferSizesWork() {
             ts.assertNoErrors();
         }
     }
+    
+    @Test
+    public void synchronousRebatching() {
+        final List<Long> requests = new ArrayList<Long>();
+        
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+            
+        Observable.range(1, 50)
+        .doOnRequest(new Action1<Long>() {
+            @Override
+            public void call(Long r) {
+                requests.add(r);
+            }
+        })
+       .rebatchRequests(20)
+       .subscribe(ts);
+       
+       ts.assertValueCount(50);
+       ts.assertNoErrors();
+       ts.assertCompleted();
+       
+       assertEquals(Arrays.asList(20L, 15L, 15L, 15L), requests);
+    }
+    
+    @Test
+    public void rebatchRequestsArgumentCheck() {
+        try {
+            Observable.never().rebatchRequests(-99);
+            fail("Didn't throw IAE");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("n > 0 required but it was -99", ex.getMessage());
+        }
+    }
 }

From 271c83b05a929943a8f12616c180ab6b9f15a087 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 1 Jun 2016 23:54:18 +0200
Subject: [PATCH 041/263] 1.x: promote UnicastSubject to be a
 standard+experimental Subject (#3936)

---
 .../OperatorWindowWithObservable.java         |  1 +
 .../OperatorWindowWithObservableFactory.java  |  1 +
 .../operators/OperatorWindowWithSize.java     |  2 +-
 .../OperatorWindowWithStartEndObservable.java |  1 +
 .../operators/OperatorWindowWithTime.java     |  1 +
 .../UnicastSubject.java                       | 21 ++++++++++++-------
 .../operators/OperatorConcatTest.java         |  2 +-
 .../BufferUntilSubscriberTest.java            |  3 +--
 8 files changed, 21 insertions(+), 11 deletions(-)
 rename src/main/java/rx/{internal/operators => subjects}/UnicastSubject.java (97%)
 rename src/test/java/rx/{internal/operators => subjects}/BufferUntilSubscriberTest.java (98%)

diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java b/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
index 4b2cbb7dd8..6d7324bf9f 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
@@ -22,6 +22,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.observers.SerializedSubscriber;
+import rx.subjects.UnicastSubject;
 
 /**
  * Creates non-overlapping windows of items where each window is terminated by
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
index 5ac748e6f1..9dbfed2bb7 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
@@ -23,6 +23,7 @@
 import rx.Observer;
 import rx.functions.Func0;
 import rx.observers.SerializedSubscriber;
+import rx.subjects.UnicastSubject;
 import rx.subscriptions.SerialSubscription;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithSize.java b/src/main/java/rx/internal/operators/OperatorWindowWithSize.java
index 3538991526..4873a3109b 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithSize.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithSize.java
@@ -23,7 +23,7 @@
 import rx.Observable.Operator;
 import rx.functions.Action0;
 import rx.internal.util.atomic.SpscLinkedArrayQueue;
-import rx.subjects.Subject;
+import rx.subjects.*;
 import rx.subscriptions.Subscriptions;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java b/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
index 07dea16e76..28a6fffc21 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
@@ -23,6 +23,7 @@
 import rx.Observer;
 import rx.functions.Func1;
 import rx.observers.*;
+import rx.subjects.UnicastSubject;
 import rx.subscriptions.CompositeSubscription;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithTime.java b/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
index d55f0db31c..8ea74a3e1a 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
@@ -25,6 +25,7 @@
 import rx.Observer;
 import rx.functions.Action0;
 import rx.observers.*;
+import rx.subjects.UnicastSubject;
 import rx.subscriptions.Subscriptions;
 
 /**
diff --git a/src/main/java/rx/internal/operators/UnicastSubject.java b/src/main/java/rx/subjects/UnicastSubject.java
similarity index 97%
rename from src/main/java/rx/internal/operators/UnicastSubject.java
rename to src/main/java/rx/subjects/UnicastSubject.java
index 569745358e..f401c364f1 100644
--- a/src/main/java/rx/internal/operators/UnicastSubject.java
+++ b/src/main/java/rx/subjects/UnicastSubject.java
@@ -13,18 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.internal.operators;
+package rx.subjects;
 
 import java.util.Queue;
 import java.util.concurrent.atomic.*;
 
 import rx.*;
+import rx.annotations.Experimental;
 import rx.exceptions.*;
-import rx.functions.*;
+import rx.functions.Action0;
+import rx.internal.operators.*;
 import rx.internal.util.atomic.*;
 import rx.internal.util.unsafe.*;
-import rx.subjects.Subject;
-import rx.subscriptions.Subscriptions;
 
 /**
  * A Subject variant which buffers events until a single Subscriber arrives and replays them to it
@@ -35,6 +35,7 @@
  * 
  * @param <T> the input and output value type
  */
+@Experimental
 public final class UnicastSubject<T> extends Subject<T, T> {
 
     /**
@@ -111,7 +112,7 @@ public boolean hasObservers() {
      *
      * @param <T> the value type
      */
-    static final class State<T> extends AtomicLong implements Producer, Observer<T>, Action0, OnSubscribe<T> {
+    static final class State<T> extends AtomicLong implements Producer, Observer<T>, OnSubscribe<T>, Subscription {
         /** */
         private static final long serialVersionUID = -9044104859202255786L;
         /** The single subscriber. */
@@ -250,7 +251,7 @@ public void request(long n) {
         @Override
         public void call(Subscriber<? super T> subscriber) {
             if (this.subscriber.compareAndSet(null, subscriber)) {
-                subscriber.add(Subscriptions.create(this));
+                subscriber.add(this);
                 subscriber.setProducer(this);
             } else {
                 subscriber.onError(new IllegalStateException("Only a single subscriber is allowed"));
@@ -326,7 +327,7 @@ void replay() {
          * Should be called only when the child unsubscribes
          */
         @Override
-        public void call() {
+        public void unsubscribe() {
 
             doTerminate();
 
@@ -339,6 +340,12 @@ public void call() {
             }
             queue.clear();
         }
+        
+        @Override
+        public boolean isUnsubscribed() {
+            return done;
+        }
+        
         /**
          * Checks if one of the terminal conditions have been met: child unsubscribed,
          * an error happened or the source terminated and the queue is empty
diff --git a/src/test/java/rx/internal/operators/OperatorConcatTest.java b/src/test/java/rx/internal/operators/OperatorConcatTest.java
index d11c16cd6f..65487798b9 100644
--- a/src/test/java/rx/internal/operators/OperatorConcatTest.java
+++ b/src/test/java/rx/internal/operators/OperatorConcatTest.java
@@ -42,7 +42,7 @@
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
-import rx.subjects.Subject;
+import rx.subjects.*;
 import rx.subscriptions.BooleanSubscription;
 
 public class OperatorConcatTest {
diff --git a/src/test/java/rx/internal/operators/BufferUntilSubscriberTest.java b/src/test/java/rx/subjects/BufferUntilSubscriberTest.java
similarity index 98%
rename from src/test/java/rx/internal/operators/BufferUntilSubscriberTest.java
rename to src/test/java/rx/subjects/BufferUntilSubscriberTest.java
index 801138d4ab..556254ae9f 100644
--- a/src/test/java/rx/internal/operators/BufferUntilSubscriberTest.java
+++ b/src/test/java/rx/subjects/BufferUntilSubscriberTest.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.internal.operators;
+package rx.subjects;
 
 import java.util.List;
 import java.util.concurrent.*;
@@ -26,7 +26,6 @@
 import rx.functions.*;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
-import rx.subjects.PublishSubject;
 
 public class BufferUntilSubscriberTest {
 

From 66c82b00a46861f29e381e1f5f98551fcbf16e96 Mon Sep 17 00:00:00 2001
From: Shixiong Zhu <zsxwing@gmail.com>
Date: Wed, 1 Jun 2016 16:17:38 -0700
Subject: [PATCH 042/263] 1.x: Use the correct Throwable to set the cause for
 CompositeException (#3977)

The cause of #3679 is we use a wrong Throwable (its cause has been set) to set the cause and `initCause` will throw an exception. Hence, the cause chain is not created correctly. In this PR, it searches the root cause (which doesn't have a cause) and use it to call `initCause`.
---
 .../rx/exceptions/CompositeException.java     | 29 +++++++++++++--
 .../rx/exceptions/CompositeExceptionTest.java | 37 +++++++++++++++++++
 2 files changed, 62 insertions(+), 4 deletions(-)

diff --git a/src/main/java/rx/exceptions/CompositeException.java b/src/main/java/rx/exceptions/CompositeException.java
index b093c41437..310cfab8ae 100644
--- a/src/main/java/rx/exceptions/CompositeException.java
+++ b/src/main/java/rx/exceptions/CompositeException.java
@@ -147,13 +147,12 @@ public synchronized Throwable getCause() {
                 // we now have 'e' as the last in the chain
                 try {
                     chain.initCause(e);
-                    chain = chain.getCause();
                 } catch (Throwable t) {
                     // ignore
                     // the javadocs say that some Throwables (depending on how they're made) will never
                     // let me call initCause without blowing up even if it returns null
-                    chain = e;
                 }
+                chain = getRootCause(chain);
             }
             cause = _cause;
         }
@@ -280,12 +279,13 @@ public String getMessage() {
     private List<Throwable> getListOfCauses(Throwable ex) {
         List<Throwable> list = new ArrayList<Throwable>();
         Throwable root = ex.getCause();
-        if (root == null) {
+        if (root == null || root == ex) {
             return list;
         } else {
             while(true) {
                 list.add(root);
-                if (root.getCause() == null) {
+                Throwable cause = root.getCause();
+                if (cause == null || cause == root) {
                     return list;
                 } else {
                     root = root.getCause();
@@ -293,4 +293,25 @@ private List<Throwable> getListOfCauses(Throwable ex) {
             }
         }
     }
+
+    /**
+     * Returns the root cause of {@code e}. If {@code e.getCause()} returns {@null} or {@code e}, just return {@code e} itself.
+     *
+     * @param e the {@link Throwable} {@code e}.
+     * @return The root cause of {@code e}. If {@code e.getCause()} returns {@null} or {@code e}, just return {@code e} itself.
+     */
+    private Throwable getRootCause(Throwable e) {
+        Throwable root = e.getCause();
+        if (root == null || root == e) {
+            return e;
+        } else {
+            while(true) {
+                Throwable cause = root.getCause();
+                if (cause == null || cause == root) {
+                    return root;
+                }
+                root = root.getCause();
+            }
+        }
+    }
 }
diff --git a/src/test/java/rx/exceptions/CompositeExceptionTest.java b/src/test/java/rx/exceptions/CompositeExceptionTest.java
index cba638e566..9cfc7fa6dd 100644
--- a/src/test/java/rx/exceptions/CompositeExceptionTest.java
+++ b/src/test/java/rx/exceptions/CompositeExceptionTest.java
@@ -28,6 +28,8 @@
 
 import org.junit.Test;
 
+import rx.exceptions.CompositeException.CompositeExceptionCausalChain;
+
 public class CompositeExceptionTest {
 
     private final Throwable ex1 = new Throwable("Ex1");
@@ -239,4 +241,39 @@ public void messageVarargs() {
         CompositeException compositeException = new CompositeException(ex1, ex2, ex3);
         assertEquals("3 exceptions occurred. ", compositeException.getMessage());
     }
+
+    @Test
+    public void complexCauses() {
+        Throwable e1 = new Throwable("1");
+        Throwable e2 = new Throwable("2");
+        e1.initCause(e2);
+
+        Throwable e3 = new Throwable("3");
+        Throwable e4 = new Throwable("4");
+        e3.initCause(e4);
+
+        Throwable e5 = new Throwable("5");
+        Throwable e6 = new Throwable("6");
+        e5.initCause(e6);
+
+        CompositeException compositeException = new CompositeException(e1, e3, e5);
+        assert(compositeException.getCause() instanceof CompositeExceptionCausalChain);
+
+        List<Throwable> causeChain = new ArrayList<Throwable>();
+        Throwable cause = compositeException.getCause().getCause();
+        while (cause != null) {
+            causeChain.add(cause);
+            cause = cause.getCause();
+        }
+        // The original relations
+        //
+        // e1 -> e2
+        // e3 -> e4
+        // e5 -> e6
+        //
+        // will be set to
+        //
+        // e1 -> e2 -> e3 -> e4 -> e5 -> e6
+        assertEquals(Arrays.asList(e1, e2, e3, e4, e5, e6), causeChain);
+    }
 }
\ No newline at end of file

From 60041569cf620551bb517c3f42469338d767ffeb Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 2 Jun 2016 08:17:26 +0200
Subject: [PATCH 043/263] 1.x: document zip() eagerness (#3981)

Closes #3960 and #3124.
---
 src/main/java/rx/Observable.java | 197 +++++++++++++++++++++++++++++--
 1 file changed, 189 insertions(+), 8 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 48d2f3adc6..b48299cd65 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -3081,8 +3081,24 @@ public static <T, Resource> Observable<T> using(
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@code onNext} as many times as
      * the number of {@code onNext} invocations of the source Observable that emits the fewest items.
      * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if 
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
+     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>zip(Arrays.asList(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2)), (a) -&gt; a)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * or unsubscription.
+     * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/zip.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3115,8 +3131,24 @@ public static <R> Observable<R> zip(Iterable<? extends Observable<?>> ws, FuncN<
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@code onNext} as many times as
      * the number of {@code onNext} invocations of the source Observable that emits the fewest items.
      * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if 
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
+     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>zip(just(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2)), (a) -&gt; a)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * or unsubscription.
+     * <p>
      * <img width="640" height="370" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/zip.o.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3147,7 +3179,23 @@ public static <R> Observable<R> zip(Observable<? extends Observable<?>> ws, fina
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext}
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
-     * <dl>
+     * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if 
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
+     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), (a, b) -&gt; a + b)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * or unsubscription.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3181,7 +3229,23 @@ public static <T1, T2, R> Observable<R> zip(Observable<? extends T1> o1, Observa
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext}
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
-     * <dl>
+     * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if 
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
+     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c) -&gt; a + b)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * or unsubscription.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3217,7 +3281,23 @@ public static <T1, T2, T3, R> Observable<R> zip(Observable<? extends T1> o1, Obs
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext}
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
-     * <dl>
+     * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if 
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
+     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d) -&gt; a + b)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * or unsubscription.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3255,7 +3335,23 @@ public static <T1, T2, T3, T4, R> Observable<R> zip(Observable<? extends T1> o1,
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext}
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
-     * <dl>
+     * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if 
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
+     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d, e) -&gt; a + b)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * or unsubscription.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3294,7 +3390,23 @@ public static <T1, T2, T3, T4, T5, R> Observable<R> zip(Observable<? extends T1>
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext}
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
-     * <dl>
+     * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if 
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
+     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d, e, f) -&gt; a + b)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * or unsubscription.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3336,7 +3448,23 @@ public static <T1, T2, T3, T4, T5, T6, R> Observable<R> zip(Observable<? extends
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext}
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
-     * <dl>
+     * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if 
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
+     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d, e, f, g) -&gt; a + b)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * or unsubscription.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3380,7 +3508,23 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> zip(Observable<? ext
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext}
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
-     * <dl>
+     * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if 
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
+     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d, e, f, g, h) -&gt; a + b)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * or unsubscription.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3426,7 +3570,23 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> zip(Observable<?
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@link Observer#onNext onNext}
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
-     * <dl>
+     * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if 
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
+     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d, e, f, g, h, i) -&gt; a + b)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * or unsubscription.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10331,6 +10491,10 @@ public final <U> Observable<Observable<T>> window(Observable<U> boundary) {
      * Note that the {@code other} Iterable is evaluated as items are observed from the source Observable; it is
      * not pre-consumed. This allows you to zip infinite streams on either side.
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zipWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10356,8 +10520,25 @@ public final <T2, R> Observable<R> zipWith(Iterable<? extends T2> other, Func2<?
      * Returns an Observable that emits items that are the result of applying a specified function to pairs of
      * values, one each from the source Observable and another specified Observable.
      * <p>
+     * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if 
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
+     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>range(1, 5).doOnCompleted(action1).zipWith(range(6, 5).doOnCompleted(action2), (a, b) -&gt; a + b)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * or unsubscription.
+     * 
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/zip.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zipWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>

From f8b6bd25ef54fd4a8e7f5b19da236dfcfa941c5b Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 3 Jun 2016 12:49:11 +0200
Subject: [PATCH 044/263] Add more time to certain tests that failed under
 heavy CI load (#3987)

---
 src/test/java/rx/internal/operators/OperatorSwitchTest.java     | 2 +-
 src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java | 2 +-
 src/test/java/rx/schedulers/ComputationSchedulerTests.java      | 2 +-
 src/test/java/rx/schedulers/IoSchedulerTest.java                | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/test/java/rx/internal/operators/OperatorSwitchTest.java b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
index 9a8178cb28..836192d3e6 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
@@ -867,7 +867,7 @@ public void call(Throwable e) {
                             });
                 }
             })
-            .timeout(10, TimeUnit.SECONDS)
+            .timeout(20, TimeUnit.SECONDS)
             .subscribe(ts);
             
             ts.awaitTerminalEvent(45, TimeUnit.SECONDS);
diff --git a/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java b/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java
index fad2435ce1..f80a32b041 100644
--- a/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java
+++ b/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java
@@ -48,7 +48,7 @@ public final void testHandledErrorIsNotDeliveredToThreadHandler() throws Interru
         SchedulerTests.testHandledErrorIsNotDeliveredToThreadHandler(getScheduler());
     }
     
-    @Test(timeout = 30000)
+    @Test(timeout = 60000)
     public void testCancelledTaskRetention() throws InterruptedException {
         ExecutorService exec = Executors.newSingleThreadExecutor();
         Scheduler s = Schedulers.from(exec);
diff --git a/src/test/java/rx/schedulers/ComputationSchedulerTests.java b/src/test/java/rx/schedulers/ComputationSchedulerTests.java
index 392ee03ccd..2988fab822 100644
--- a/src/test/java/rx/schedulers/ComputationSchedulerTests.java
+++ b/src/test/java/rx/schedulers/ComputationSchedulerTests.java
@@ -153,7 +153,7 @@ public final void testHandledErrorIsNotDeliveredToThreadHandler() throws Interru
         SchedulerTests.testHandledErrorIsNotDeliveredToThreadHandler(getScheduler());
     }
     
-    @Test(timeout = 30000)
+    @Test(timeout = 60000)
     public void testCancelledTaskRetention() throws InterruptedException {
         Worker w = Schedulers.computation().createWorker();
         try {
diff --git a/src/test/java/rx/schedulers/IoSchedulerTest.java b/src/test/java/rx/schedulers/IoSchedulerTest.java
index 38ddb2a2dd..775f6fd507 100644
--- a/src/test/java/rx/schedulers/IoSchedulerTest.java
+++ b/src/test/java/rx/schedulers/IoSchedulerTest.java
@@ -67,7 +67,7 @@ public final void testHandledErrorIsNotDeliveredToThreadHandler() throws Interru
         SchedulerTests.testHandledErrorIsNotDeliveredToThreadHandler(getScheduler());
     }
     
-    @Test(timeout = 30000)
+    @Test(timeout = 60000)
     public void testCancelledTaskRetention() throws InterruptedException {
         Worker w = Schedulers.io().createWorker();
         try {

From f78c0d4904ab7463a28449c2da92cd7e0850ef5f Mon Sep 17 00:00:00 2001
From: Zac Sweers <pandanomic@gmail.com>
Date: Mon, 6 Jun 2016 14:41:21 -0700
Subject: [PATCH 045/263] Add Schedulers.reset() for better testing (#3986)

* Add Schedulers.reset() for better testing

Resolves #3985

* More accurate doc
---
 src/main/java/rx/schedulers/Schedulers.java   | 52 +++++++++++++++----
 .../rx/schedulers/ResetSchedulersTest.java    | 50 ++++++++++++++++++
 2 files changed, 91 insertions(+), 11 deletions(-)
 create mode 100644 src/test/java/rx/schedulers/ResetSchedulersTest.java

diff --git a/src/main/java/rx/schedulers/Schedulers.java b/src/main/java/rx/schedulers/Schedulers.java
index eae594ef08..269c836864 100644
--- a/src/main/java/rx/schedulers/Schedulers.java
+++ b/src/main/java/rx/schedulers/Schedulers.java
@@ -16,12 +16,16 @@
 package rx.schedulers;
 
 import rx.Scheduler;
-import rx.internal.schedulers.*;
+import rx.annotations.Experimental;
+import rx.internal.schedulers.ExecutorScheduler;
+import rx.internal.schedulers.GenericScheduledExecutorService;
+import rx.internal.schedulers.SchedulerLifecycle;
 import rx.internal.util.RxRingBuffer;
 import rx.plugins.RxJavaPlugins;
 import rx.plugins.RxJavaSchedulersHook;
 
 import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * Static factory methods for creating Schedulers.
@@ -32,7 +36,22 @@ public final class Schedulers {
     private final Scheduler ioScheduler;
     private final Scheduler newThreadScheduler;
 
-    private static final Schedulers INSTANCE = new Schedulers();
+    private static final AtomicReference<Schedulers> INSTANCE = new AtomicReference<Schedulers>();
+
+    private static Schedulers getInstance() {
+        for (;;) {
+            Schedulers current = INSTANCE.get();
+            if (current != null) {
+                return current;
+            }
+            current = new Schedulers();
+            if (INSTANCE.compareAndSet(null, current)) {
+                return current;
+            } else {
+                shutdown();
+            }
+        }
+    }
 
     private Schedulers() {
         RxJavaSchedulersHook hook = RxJavaPlugins.getInstance().getSchedulersHook();
@@ -86,7 +105,7 @@ public static Scheduler trampoline() {
      * @return a {@link Scheduler} that creates new threads
      */
     public static Scheduler newThread() {
-        return INSTANCE.newThreadScheduler;
+        return getInstance().newThreadScheduler;
     }
 
     /**
@@ -101,7 +120,7 @@ public static Scheduler newThread() {
      * @return a {@link Scheduler} meant for computation-bound work
      */
     public static Scheduler computation() {
-        return INSTANCE.computationScheduler;
+        return getInstance().computationScheduler;
     }
 
     /**
@@ -118,7 +137,7 @@ public static Scheduler computation() {
      * @return a {@link Scheduler} meant for IO-bound work
      */
     public static Scheduler io() {
-        return INSTANCE.ioScheduler;
+        return getInstance().ioScheduler;
     }
 
     /**
@@ -141,13 +160,24 @@ public static TestScheduler test() {
     public static Scheduler from(Executor executor) {
         return new ExecutorScheduler(executor);
     }
+
+    /**
+     * Resets the current {@link Schedulers} instance.
+     * This will re-init the cached schedulers on the next usage,
+     * which can be useful in testing.
+     */
+    @Experimental
+    public static void reset() {
+        shutdown();
+        INSTANCE.set(null);
+    }
     
     /**
      * Starts those standard Schedulers which support the SchedulerLifecycle interface.
      * <p>The operation is idempotent and threadsafe.
      */
     /* public test only */ static void start() {
-        Schedulers s = INSTANCE;
+        Schedulers s = getInstance();
         synchronized (s) {
             if (s.computationScheduler instanceof SchedulerLifecycle) {
                 ((SchedulerLifecycle) s.computationScheduler).start();
@@ -170,7 +200,7 @@ public static Scheduler from(Executor executor) {
      * <p>The operation is idempotent and threadsafe.
      */
     public static void shutdown() {
-        Schedulers s = INSTANCE;
+        Schedulers s = getInstance();
         synchronized (s) {
             if (s.computationScheduler instanceof SchedulerLifecycle) {
                 ((SchedulerLifecycle) s.computationScheduler).shutdown();
@@ -181,12 +211,12 @@ public static void shutdown() {
             if (s.newThreadScheduler instanceof SchedulerLifecycle) {
                 ((SchedulerLifecycle) s.newThreadScheduler).shutdown();
             }
-            
+
             GenericScheduledExecutorService.INSTANCE.shutdown();
-            
+
             RxRingBuffer.SPSC_POOL.shutdown();
-            
+
             RxRingBuffer.SPMC_POOL.shutdown();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/rx/schedulers/ResetSchedulersTest.java b/src/test/java/rx/schedulers/ResetSchedulersTest.java
new file mode 100644
index 0000000000..79c9f9435b
--- /dev/null
+++ b/src/test/java/rx/schedulers/ResetSchedulersTest.java
@@ -0,0 +1,50 @@
+package rx.schedulers;
+
+
+import org.junit.Test;
+import rx.Scheduler;
+import rx.internal.schedulers.*;
+import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaSchedulersHook;
+
+import static org.junit.Assert.assertTrue;
+
+public class ResetSchedulersTest {
+
+    @Test
+    public void reset() {
+        RxJavaPlugins.getInstance().reset();
+
+        final TestScheduler testScheduler = new TestScheduler();
+        RxJavaPlugins.getInstance().registerSchedulersHook(new RxJavaSchedulersHook() {
+            @Override
+            public Scheduler getComputationScheduler() {
+                return testScheduler;
+            }
+
+            @Override
+            public Scheduler getIOScheduler() {
+                return testScheduler;
+            }
+
+            @Override
+            public Scheduler getNewThreadScheduler() {
+                return testScheduler;
+            }
+        });
+        Schedulers.reset();
+
+        assertTrue(Schedulers.io().equals(testScheduler));
+        assertTrue(Schedulers.computation().equals(testScheduler));
+        assertTrue(Schedulers.newThread().equals(testScheduler));
+
+        RxJavaPlugins.getInstance().reset();
+        RxJavaPlugins.getInstance().registerSchedulersHook(RxJavaSchedulersHook.getDefaultInstance());
+        Schedulers.reset();
+
+        assertTrue(Schedulers.io() instanceof CachedThreadScheduler);
+        assertTrue(Schedulers.computation() instanceof EventLoopsScheduler);
+        assertTrue(Schedulers.newThread() instanceof rx.internal.schedulers.NewThreadScheduler);
+    }
+
+}

From 08a2130d3eeee0ec12b9dd496e99c57fc668a496 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 8 Jun 2016 01:06:52 +0200
Subject: [PATCH 046/263] 1.x: fix reset() shutting down everything other than
 the schedulers (#3996)

---
 src/main/java/rx/schedulers/Schedulers.java | 64 +++++++++++++--------
 1 file changed, 41 insertions(+), 23 deletions(-)

diff --git a/src/main/java/rx/schedulers/Schedulers.java b/src/main/java/rx/schedulers/Schedulers.java
index 269c836864..031d0bb463 100644
--- a/src/main/java/rx/schedulers/Schedulers.java
+++ b/src/main/java/rx/schedulers/Schedulers.java
@@ -48,7 +48,7 @@ private static Schedulers getInstance() {
             if (INSTANCE.compareAndSet(null, current)) {
                 return current;
             } else {
-                shutdown();
+                current.shutdownInstance();
             }
         }
     }
@@ -168,8 +168,10 @@ public static Scheduler from(Executor executor) {
      */
     @Experimental
     public static void reset() {
-        shutdown();
-        INSTANCE.set(null);
+        Schedulers s = INSTANCE.getAndSet(null);
+        if (s != null) {
+            s.shutdownInstance();
+        }
     }
     
     /**
@@ -178,16 +180,10 @@ public static void reset() {
      */
     /* public test only */ static void start() {
         Schedulers s = getInstance();
+        
+        s.startInstance();
+        
         synchronized (s) {
-            if (s.computationScheduler instanceof SchedulerLifecycle) {
-                ((SchedulerLifecycle) s.computationScheduler).start();
-            }
-            if (s.ioScheduler instanceof SchedulerLifecycle) {
-                ((SchedulerLifecycle) s.ioScheduler).start();
-            }
-            if (s.newThreadScheduler instanceof SchedulerLifecycle) {
-                ((SchedulerLifecycle) s.newThreadScheduler).start();
-            }
             GenericScheduledExecutorService.INSTANCE.start();
             
             RxRingBuffer.SPSC_POOL.start();
@@ -201,22 +197,44 @@ public static void reset() {
      */
     public static void shutdown() {
         Schedulers s = getInstance();
-        synchronized (s) {
-            if (s.computationScheduler instanceof SchedulerLifecycle) {
-                ((SchedulerLifecycle) s.computationScheduler).shutdown();
-            }
-            if (s.ioScheduler instanceof SchedulerLifecycle) {
-                ((SchedulerLifecycle) s.ioScheduler).shutdown();
-            }
-            if (s.newThreadScheduler instanceof SchedulerLifecycle) {
-                ((SchedulerLifecycle) s.newThreadScheduler).shutdown();
-            }
+        s.shutdownInstance();
 
+        synchronized (s) {
             GenericScheduledExecutorService.INSTANCE.shutdown();
-
+            
             RxRingBuffer.SPSC_POOL.shutdown();
 
             RxRingBuffer.SPMC_POOL.shutdown();
         }
     }
+    
+    /**
+     * Start the instance-specific schedulers.
+     */
+    synchronized void startInstance() {
+        if (computationScheduler instanceof SchedulerLifecycle) {
+            ((SchedulerLifecycle) computationScheduler).start();
+        }
+        if (ioScheduler instanceof SchedulerLifecycle) {
+            ((SchedulerLifecycle) ioScheduler).start();
+        }
+        if (newThreadScheduler instanceof SchedulerLifecycle) {
+            ((SchedulerLifecycle) newThreadScheduler).start();
+        }
+    }
+    
+    /**
+     * Start the instance-specific schedulers.
+     */
+    synchronized void shutdownInstance() {
+        if (computationScheduler instanceof SchedulerLifecycle) {
+            ((SchedulerLifecycle) computationScheduler).shutdown();
+        }
+        if (ioScheduler instanceof SchedulerLifecycle) {
+            ((SchedulerLifecycle) ioScheduler).shutdown();
+        }
+        if (newThreadScheduler instanceof SchedulerLifecycle) {
+            ((SchedulerLifecycle) newThreadScheduler).shutdown();
+        }
+    }
 }

From 67b7be02666371379d9df41c9d8ec6ff1c14900d Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 15 Jun 2016 20:17:47 +0200
Subject: [PATCH 047/263] 1.x: replay request coordination reduce overhead
 (#3470)

---
 .../rx/internal/operators/OperatorReplay.java | 275 +++++++++++-------
 .../java/rx/internal/util/OpenHashSet.java    | 211 ++++++++++++++
 .../rx/internal/util/OpenHashSetTest.java     |  58 ++++
 3 files changed, 435 insertions(+), 109 deletions(-)
 create mode 100644 src/main/java/rx/internal/util/OpenHashSet.java
 create mode 100644 src/test/java/rx/internal/util/OpenHashSetTest.java

diff --git a/src/main/java/rx/internal/operators/OperatorReplay.java b/src/main/java/rx/internal/operators/OperatorReplay.java
index 1d92afa637..7cec48cc25 100644
--- a/src/main/java/rx/internal/operators/OperatorReplay.java
+++ b/src/main/java/rx/internal/operators/OperatorReplay.java
@@ -21,9 +21,9 @@
 
 import rx.*;
 import rx.Observable;
-import rx.exceptions.Exceptions;
-import rx.exceptions.OnErrorThrowable;
+import rx.exceptions.*;
 import rx.functions.*;
+import rx.internal.util.OpenHashSet;
 import rx.observables.ConnectableObservable;
 import rx.schedulers.Timestamped;
 import rx.subscriptions.Subscriptions;
@@ -314,8 +314,16 @@ static final class ReplaySubscriber<T> extends Subscriber<T> implements Subscrip
         /** Indicates a terminated ReplaySubscriber. */
         static final InnerProducer[] TERMINATED = new InnerProducer[0];
         
-        /** Tracks the subscribed producers. */
-        final AtomicReference<InnerProducer[]> producers;
+        /** Indicates no further InnerProducers are accepted. */
+        volatile boolean terminated;
+        /** Tracks the subscribed producers. Guarded by itself. */
+        final OpenHashSet<InnerProducer<T>> producers;
+        /** Contains a copy of the producers. Modified only from the source side. */
+        InnerProducer<T>[] producersCache;
+        /** Contains number of modifications to the producers set.*/
+        volatile long producersVersion;
+        /** Contains the number of modifications that the producersCache holds. */
+        long producersCacheVersion;
         /** 
          * Atomically changed from false to true by connect to make sure the 
          * connection is only performed by one thread. 
@@ -335,12 +343,19 @@ static final class ReplaySubscriber<T> extends Subscriber<T> implements Subscrip
         /** The upstream producer. */
         volatile Producer producer;
         
+        /** The queue that holds producers with request changes that need to be coordinated. */
+        List<InnerProducer<T>> coordinationQueue;
+        /** Indicate that all request amounts should be considered. */
+        boolean coordinateAll;
+        
+        @SuppressWarnings("unchecked")
         public ReplaySubscriber(AtomicReference<ReplaySubscriber<T>> current,
                 ReplayBuffer<T> buffer) {
             this.buffer = buffer;
             
             this.nl = NotificationLite.instance();
-            this.producers = new AtomicReference<InnerProducer[]>(EMPTY);
+            this.producers = new OpenHashSet<InnerProducer<T>>();
+            this.producersCache = EMPTY;
             this.shouldConnect = new AtomicBoolean();
             // make sure the source doesn't produce values until the child subscribers
             // expressed their request amounts
@@ -351,7 +366,15 @@ void init() {
             add(Subscriptions.create(new Action0() {
                 @Override
                 public void call() {
-                    ReplaySubscriber.this.producers.getAndSet(TERMINATED);
+                    if (!terminated) {
+                        synchronized (producers) {
+                            if (!terminated) {
+                                producers.terminate();
+                                producersVersion++;
+                                terminated = true;
+                            }
+                        }
+                    }
                     // unlike OperatorPublish, we can't null out the terminated so
                     // late subscribers can still get replay
                     // current.compareAndSet(ReplaySubscriber.this, null);
@@ -370,27 +393,18 @@ boolean add(InnerProducer<T> producer) {
             if (producer == null) {
                 throw new NullPointerException();
             }
-            // the state can change so we do a CAS loop to achieve atomicity
-            for (;;) {
-                // get the current producer array
-                InnerProducer[] c = producers.get();
-                // if this subscriber-to-source reached a terminal state by receiving 
-                // an onError or onCompleted, just refuse to add the new producer
-                if (c == TERMINATED) {
+            if (terminated) {
+                return false;
+            }
+            synchronized (producers) {
+                if (terminated) {
                     return false;
                 }
-                // we perform a copy-on-write logic
-                int len = c.length;
-                InnerProducer[] u = new InnerProducer[len + 1];
-                System.arraycopy(c, 0, u, 0, len);
-                u[len] = producer;
-                // try setting the producers array
-                if (producers.compareAndSet(c, u)) {
-                    return true;
-                }
-                // if failed, some other operation succeeded (another add, remove or termination)
-                // so retry
+                
+                producers.add(producer);
+                producersVersion++;
             }
+            return true;
         }
         
         /**
@@ -398,48 +412,15 @@ boolean add(InnerProducer<T> producer) {
          * @param producer the producer to remove
          */
         void remove(InnerProducer<T> producer) {
-            // the state can change so we do a CAS loop to achieve atomicity
-            for (;;) {
-                // let's read the current producers array
-                InnerProducer[] c = producers.get();
-                // if it is either empty or terminated, there is nothing to remove so we quit
-                if (c == EMPTY || c == TERMINATED) {
-                    return;
-                }
-                // 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;
-                int len = c.length;
-                for (int i = 0; i < len; i++) {
-                    if (c[i].equals(producer)) {
-                        j = i;
-                        break;
-                    }
-                }
-                // we didn't find it so just quit
-                if (j < 0) {
-                    return;
-                }
-                // we do copy-on-write logic here
-                InnerProducer[] 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 InnerProducer[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 (producers.compareAndSet(c, u)) {
+            if (terminated) {
+                return;
+            }
+            synchronized (producers) {
+                if (terminated) {
                     return;
                 }
-                // if we failed, it means something else happened
-                // (a concurrent add/remove or termination), we need to retry
+                producers.remove(producer);
+                producersVersion++;
             }
         }
         
@@ -450,7 +431,7 @@ public void setProducer(Producer p) {
                 throw new IllegalStateException("Only a single producer can be set on a Subscriber.");
             }
             producer = p;
-            manageRequests();
+            manageRequests(null);
             replay();
         }
         
@@ -493,81 +474,157 @@ public void onCompleted() {
         /**
          * Coordinates the request amounts of various child Subscribers.
          */
-        void manageRequests() {
+        void manageRequests(InnerProducer<T> inner) {
             // if the upstream has completed, no more requesting is possible
             if (isUnsubscribed()) {
                 return;
             }
             synchronized (this) {
                 if (emitting) {
+                    if (inner != null) {
+                        List<InnerProducer<T>> q = coordinationQueue;
+                        if (q == null) {
+                            q = new ArrayList<InnerProducer<T>>();
+                            coordinationQueue = q;
+                        }
+                        q.add(inner);
+                    } else {
+                        coordinateAll = true;
+                    }
                     missed = true;
                     return;
                 }
                 emitting = true;
             }
+            
+            long ri = maxChildRequested;
+            long maxTotalRequested;
+            
+            if (inner != null) {
+                maxTotalRequested = Math.max(ri, inner.totalRequested.get());
+            } else {
+                maxTotalRequested = ri;
+
+                InnerProducer<T>[] a = copyProducers();
+                for (InnerProducer<T> rp : a) {
+                    if (rp != null) {
+                        maxTotalRequested = Math.max(maxTotalRequested, rp.totalRequested.get());
+                    }
+                }
+                
+            }
+            makeRequest(maxTotalRequested, ri);
+            
             for (;;) {
                 // if the upstream has completed, no more requesting is possible
                 if (isUnsubscribed()) {
                     return;
                 }
                 
-                @SuppressWarnings("unchecked")
-                InnerProducer<T>[] a = producers.get();
-                
-                long ri = maxChildRequested;
-                long maxTotalRequests = ri;
-
-                for (InnerProducer<T> rp : a) {
-                    maxTotalRequests = Math.max(maxTotalRequests, rp.totalRequested.get());
+                List<InnerProducer<T>> q;
+                boolean all;
+                synchronized (this) {
+                    if (!missed) {
+                        emitting = false;
+                        return;
+                    }
+                    missed = false;
+                    q = coordinationQueue;
+                    coordinationQueue = null;
+                    all = coordinateAll;
+                    coordinateAll = false;
                 }
                 
-                long ur = maxUpstreamRequested;
-                Producer p = producer;
+                ri = maxChildRequested;
+                maxTotalRequested = ri;
 
-                long diff = maxTotalRequests - ri;
-                if (diff != 0) {
-                    maxChildRequested = maxTotalRequests;
-                    if (p != null) {
-                        if (ur != 0L) {
-                            maxUpstreamRequested = 0L;
-                            p.request(ur + diff);
-                        } else {
-                            p.request(diff);
-                        }
-                    } else {
-                        // collect upstream request amounts until there is a producer for them
-                        long u = ur + diff;
-                        if (u < 0) {
-                            u = Long.MAX_VALUE;
+                if (q != null) {
+                    for (InnerProducer<T> rp : q) {
+                        maxTotalRequested = Math.max(maxTotalRequested, rp.totalRequested.get());
+                    }
+                } 
+                
+                if (all) {
+                    InnerProducer<T>[] a = copyProducers();
+                    for (InnerProducer<T> rp : a) {
+                        if (rp != null) {
+                            maxTotalRequested = Math.max(maxTotalRequested, rp.totalRequested.get());
                         }
-                        maxUpstreamRequested = u;
                     }
-                } else
-                // if there were outstanding upstream requests and we have a producer
-                if (ur != 0L && p != null) {
-                    maxUpstreamRequested = 0L;
-                    // fire the accumulated requests
-                    p.request(ur);
                 }
                 
-                synchronized (this) {
-                    if (!missed) {
-                        emitting = false;
-                        return;
+                makeRequest(maxTotalRequested, ri);
+            }
+        }
+        
+        InnerProducer<T>[] copyProducers() {
+            synchronized (producers) {
+                Object[] a = producers.values();
+                int n = a.length;
+                @SuppressWarnings("unchecked")
+                InnerProducer<T>[] result = new InnerProducer[n];
+                System.arraycopy(a, 0, result, 0, n);
+                return result;
+            }
+        }
+        
+        void makeRequest(long maxTotalRequests, long previousTotalRequests) {
+            long ur = maxUpstreamRequested;
+            Producer p = producer;
+
+            long diff = maxTotalRequests - previousTotalRequests;
+            if (diff != 0) {
+                maxChildRequested = maxTotalRequests;
+                if (p != null) {
+                    if (ur != 0L) {
+                        maxUpstreamRequested = 0L;
+                        p.request(ur + diff);
+                    } else {
+                        p.request(diff);
                     }
-                    missed = false;
+                } else {
+                    // collect upstream request amounts until there is a producer for them
+                    long u = ur + diff;
+                    if (u < 0) {
+                        u = Long.MAX_VALUE;
+                    }
+                    maxUpstreamRequested = u;
                 }
+            } else
+            // if there were outstanding upstream requests and we have a producer
+            if (ur != 0L && p != null) {
+                maxUpstreamRequested = 0L;
+                // fire the accumulated requests
+                p.request(ur);
             }
         }
         
         /**
          * Tries to replay the buffer contents to all known subscribers.
          */
+        @SuppressWarnings("unchecked")
         void replay() {
-            @SuppressWarnings("unchecked")
-            InnerProducer<T>[] a = producers.get();
-            for (InnerProducer<T> rp : a) {
-                buffer.replay(rp);
+            InnerProducer<T>[] pc = producersCache;
+            if (producersCacheVersion != producersVersion) {
+                synchronized (producers) {
+                    pc = producersCache;
+                    // if the producers hasn't changed do nothing
+                    // otherwise make a copy of the current set of producers
+                    Object[] a = producers.values();
+                    int n = a.length;
+                    if (pc.length != n) {
+                        pc = new InnerProducer[n];
+                        producersCache = pc;
+                    }
+                    System.arraycopy(a, 0, pc, 0, n);
+                    producersCacheVersion = producersVersion;
+                }
+            }
+            ReplayBuffer<T> b = buffer;
+            for (InnerProducer<T> rp : pc) {
+                if (rp != null) {
+                    b.replay(rp);
+                }
             }
         }
     }
@@ -646,7 +703,7 @@ public void request(long n) {
                     addTotalRequested(n);
                     // if successful, notify the parent dispatcher this child can receive more
                     // elements
-                    parent.manageRequests();
+                    parent.manageRequests(this);
                     
                     parent.buffer.replay(this);
                     return;
@@ -727,7 +784,7 @@ public void unsubscribe() {
                     // let's assume this child had 0 requested before the unsubscription while
                     // the others had non-zero. By removing this 'blocking' child, the others
                     // are now free to receive events
-                    parent.manageRequests();
+                    parent.manageRequests(this);
                 }
             }
         }
diff --git a/src/main/java/rx/internal/util/OpenHashSet.java b/src/main/java/rx/internal/util/OpenHashSet.java
new file mode 100644
index 0000000000..1e79fdd4c1
--- /dev/null
+++ b/src/main/java/rx/internal/util/OpenHashSet.java
@@ -0,0 +1,211 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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.
+ * 
+ * Modified from http://www.javacodegeeks.com/2013/08/simple-and-lightweight-pool-implementation.html
+ */
+
+package rx.internal.util;
+
+import java.util.Arrays;
+
+import rx.functions.Action1;
+import rx.internal.util.unsafe.Pow2;
+
+/*
+ * Inspired by fastutils' OpenHashSet implementation at
+ * https://github.com/vigna/fastutil/blob/master/drv/OpenHashSet.drv
+ */
+
+/**
+ * A simple open hash set with add, remove and clear capabilities only.
+ * <p>Doesn't support nor checks for {@code null}s.
+ *
+ * @param <T> the element type
+ */
+public final class OpenHashSet<T> {
+    final float loadFactor;
+    int mask;
+    int size;
+    int maxSize;
+    T[] keys;
+    
+    public OpenHashSet() {
+        this(16, 0.75f);
+    }
+    
+    /**
+     * Creates an OpenHashSet with the initial capacity and load factor of 0.75f.
+     * @param capacity the initial capacity
+     */
+    public OpenHashSet(int capacity) {
+        this(capacity, 0.75f);
+    }
+    
+    @SuppressWarnings("unchecked")
+    public OpenHashSet(int capacity, float loadFactor) {
+        this.loadFactor = loadFactor;
+        int c = Pow2.roundToPowerOfTwo(capacity);
+        this.mask = c - 1;
+        this.maxSize = (int)(loadFactor * c);
+        this.keys = (T[])new Object[c];
+    }
+    
+    public boolean add(T value) {
+        final T[] a = keys;
+        final int m = mask;
+        
+        int pos = mix(value.hashCode()) & m;
+        T curr = a[pos];
+        if (curr != null) {
+            if (curr.equals(value)) {
+                return false;
+            }
+            for (;;) {
+                pos = (pos + 1) & m;
+                curr = a[pos];
+                if (curr == null) {
+                    break;
+                }
+                if (curr.equals(value)) {
+                    return false;
+                }
+            }
+        }
+        a[pos] = value;
+        if (++size >= maxSize) {
+            rehash();
+        }
+        return true;
+    }
+    public boolean remove(T value) {
+        T[] a = keys;
+        int m = mask;
+        int pos = mix(value.hashCode()) & m;
+        T curr = a[pos];
+        if (curr == null) {
+            return false;
+        }
+        if (curr.equals(value)) {
+            return removeEntry(pos, a, m);
+        }
+        for (;;) {
+            pos = (pos + 1) & m;
+            curr = a[pos];
+            if (curr == null) {
+                return false;
+            }
+            if (curr.equals(value)) {
+                return removeEntry(pos, a, m);
+            }
+        }
+    }
+    
+    boolean removeEntry(int pos, T[] a, int m) {
+        size--;
+        
+        int last;
+        int slot;
+        T curr;
+        for (;;) {
+            last = pos;
+            pos = (pos + 1) & m;
+            for (;;) {
+                curr = a[pos];
+                if (curr == null) {
+                    a[last] = null;
+                    return true;
+                }
+                slot = mix(curr.hashCode()) & m;
+                
+                if (last <= pos ? last >= slot || slot > pos : last >= slot && slot > pos) {
+                    break;
+                }
+                
+                pos = (pos + 1) & m;
+            }
+            a[last] = curr;
+        }
+    }
+    
+    public void clear(Action1<? super T> clearAction) {
+        if (size == 0) {
+            return;
+        }
+        T[] a = keys;
+        int len = a.length;
+        for (int i = 0; i < len; i++) {
+            T e = a[i];
+            if (e != null) {
+                clearAction.call(e);
+            }
+        }
+        Arrays.fill(a, null);
+        size = 0;
+    }
+    
+    @SuppressWarnings("unchecked")
+    public void terminate() {
+        size = 0;
+        keys = (T[])new Object[0];
+    }
+    
+    @SuppressWarnings("unchecked")
+    void rehash() {
+        T[] a = keys;
+        int i = a.length;
+        int newCap = i << 1;
+        int m = newCap - 1;
+        
+        T[] b = (T[])new Object[newCap];
+        
+        
+        for (int j = size; j-- != 0; ) {
+            while (a[--i] == null);
+            int pos = mix(a[i].hashCode()) & m;
+            if (b[pos] != null) {
+                for (;;) {
+                    pos = (pos + 1) & m;
+                    if (b[pos] == null) {
+                        break;
+                    }
+                }
+            }
+            b[pos] = a[i];
+        }
+        
+        this.mask = m;
+        this.maxSize = (int)(newCap * loadFactor);
+        this.keys = b;
+    }
+    
+    private static final int INT_PHI = 0x9E3779B9;
+    
+    static int mix(int x) {
+        final int h = x * INT_PHI;
+        return h ^ (h >>> 16);
+    }
+    
+    public boolean isEmpty() {
+        return size == 0;
+    }
+    
+    /**
+     * Returns the raw array of values of this set, watch out for null entires.
+     * @return the raw array of values of this set
+     */
+    public T[] values() {
+        return keys;
+    }
+}
diff --git a/src/test/java/rx/internal/util/OpenHashSetTest.java b/src/test/java/rx/internal/util/OpenHashSetTest.java
new file mode 100644
index 0000000000..b777bdbb50
--- /dev/null
+++ b/src/test/java/rx/internal/util/OpenHashSetTest.java
@@ -0,0 +1,58 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.internal.util;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class OpenHashSetTest {
+    @Test
+    public void addRemove() {
+        OpenHashSet<Integer> set = new OpenHashSet<Integer>();
+        
+        for (int i = 0; i < 1000; i++) {
+            assertTrue(set.add(i));
+            assertFalse(set.add(i));
+            assertTrue(set.remove(i));
+            assertFalse(set.remove(i));
+        }
+        
+        Object[] values = set.values();
+        for (Object i : values) {
+            assertNull(i);
+        }
+    }
+    
+    @Test
+    public void addAllRemoveAll() {
+        for (int i = 16; i < 128 * 1024; i *= 2) {
+            OpenHashSet<Integer> set = new OpenHashSet<Integer>(i);
+            for (int j = 0; j < i * 2; j++) {
+                assertTrue(set.add(j));
+                assertFalse(set.add(j));
+            }
+            for (int j = i * 2 - 1; j >= 0; j--) {
+                assertTrue(set.remove(j));
+                assertFalse(set.remove(j));
+            }
+            Object[] values = set.values();
+            for (Object j : values) {
+                assertNull(j);
+            }
+        }
+    }
+}

From 3261a4917c21031dc1dfa5670aff9fe1d3c521d1 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 15 Jun 2016 20:21:27 +0200
Subject: [PATCH 048/263] 1.x: fix Spsc queues reporting not empty but then
 poll() returns null (#4005)

---
 .../util/atomic/SpscAtomicArrayQueue.java     |  4 +--
 .../util/atomic/SpscLinkedArrayQueue.java     | 14 ++++-----
 .../internal/util/unsafe/SpscArrayQueue.java  |  4 +--
 .../util/unsafe/SpscUnboundedArrayQueue.java  |  8 ++---
 .../operators/OperatorSwitchTest.java         | 29 ++++++++++++++++++-
 5 files changed, 43 insertions(+), 16 deletions(-)

diff --git a/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
index cadf772d49..6240a5f156 100644
--- a/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
@@ -64,8 +64,8 @@ else if (null != lvElement(buffer, offset)){
                 return false;
             }
         }
-        soProducerIndex(index + 1); // ordered store -> atomic and ordered for size()
         soElement(buffer, offset, e); // StoreStore
+        soProducerIndex(index + 1); // ordered store -> atomic and ordered for size()
         return true;
     }
 
@@ -79,8 +79,8 @@ public E poll() {
         if (null == e) {
             return null;
         }
-        soConsumerIndex(index + 1); // ordered store -> atomic and ordered for size()
         soElement(lElementBuffer, offset, null);// StoreStore
+        soConsumerIndex(index + 1); // ordered store -> atomic and ordered for size()
         return e;
     }
 
diff --git a/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
index 23d8ad7c9e..4e4943dfcb 100644
--- a/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
@@ -90,8 +90,8 @@ public final boolean offer(final T e) {
     }
 
     private boolean writeToQueue(final AtomicReferenceArray<Object> buffer, final T e, final long index, final int offset) {
-        soProducerIndex(index + 1);// this ensures atomic write of long on 32bit platforms
         soElement(buffer, offset, e);// StoreStore
+        soProducerIndex(index + 1);// this ensures atomic write of long on 32bit platforms
         return true;
     }
 
@@ -101,11 +101,11 @@ private void resize(final AtomicReferenceArray<Object> oldBuffer, final long cur
         final AtomicReferenceArray<Object> newBuffer = new AtomicReferenceArray<Object>(capacity);
         producerBuffer = newBuffer;
         producerLookAhead = currIndex + mask - 1;
-        soProducerIndex(currIndex + 1);// this ensures correctness on 32bit platforms
         soElement(newBuffer, offset, e);// StoreStore
         soNext(oldBuffer, newBuffer);
         soElement(oldBuffer, offset, HAS_NEXT); // new buffer is visible after element is
                                                                  // inserted
+        soProducerIndex(currIndex + 1);// this ensures correctness on 32bit platforms
     }
 
     private void soNext(AtomicReferenceArray<Object> curr, AtomicReferenceArray<Object> next) {
@@ -131,8 +131,8 @@ public final T poll() {
         final Object e = lvElement(buffer, offset);// LoadLoad
         boolean isNextBuffer = e == HAS_NEXT;
         if (null != e && !isNextBuffer) {
-            soConsumerIndex(index + 1);// this ensures correctness on 32bit platforms
             soElement(buffer, offset, null);// StoreStore
+            soConsumerIndex(index + 1);// this ensures correctness on 32bit platforms
             return (T) e;
         } else if (isNextBuffer) {
             return newBufferPoll(lvNext(buffer), index, mask);
@@ -149,8 +149,8 @@ private T newBufferPoll(AtomicReferenceArray<Object> nextBuffer, final long inde
         if (null == n) {
             return null;
         } else {
-            soConsumerIndex(index + 1);// this ensures correctness on 32bit platforms
             soElement(nextBuffer, offsetInNew, null);// StoreStore
+            soConsumerIndex(index + 1);// this ensures correctness on 32bit platforms
             return n;
         }
     }
@@ -330,8 +330,8 @@ public boolean offer(T first, T second) {
         if (null == lvElement(buffer, pi)) {
             pi = calcWrappedOffset(p, m);
             soElement(buffer, pi + 1, second);
-            soProducerIndex(p + 2);
             soElement(buffer, pi, first);
+            soProducerIndex(p + 2);
         } else {
             final int capacity = buffer.length();
             final AtomicReferenceArray<Object> newBuffer = new AtomicReferenceArray<Object>(capacity);
@@ -342,9 +342,9 @@ public boolean offer(T first, T second) {
             soElement(newBuffer, pi, first);
             soNext(buffer, newBuffer);
             
-            soProducerIndex(p + 2);// this ensures correctness on 32bit platforms
-            
             soElement(buffer, pi, HAS_NEXT); // new buffer is visible after element is
+            
+            soProducerIndex(p + 2);// this ensures correctness on 32bit platforms
         }
 
         return true;
diff --git a/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
index 17fee1c804..ae9a5b771a 100644
--- a/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
@@ -110,8 +110,8 @@ public boolean offer(final E e) {
         if (null != lvElement(lElementBuffer, offset)){
             return false;
         }
-        soProducerIndex(index + 1); // ordered store -> atomic and ordered for size()
         soElement(lElementBuffer, offset, e); // StoreStore
+        soProducerIndex(index + 1); // ordered store -> atomic and ordered for size()
         return true;
     }
     
@@ -130,8 +130,8 @@ public E poll() {
         if (null == e) {
             return null;
         }
-        soConsumerIndex(index + 1); // ordered store -> atomic and ordered for size()
         soElement(lElementBuffer, offset, null);// StoreStore
+        soConsumerIndex(index + 1); // ordered store -> atomic and ordered for size()
         return e;
     }
 
diff --git a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
index 680f62860a..6175bab455 100644
--- a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
@@ -132,8 +132,8 @@ public final boolean offer(final E e) {
     }
 
     private boolean writeToQueue(final E[] buffer, final E e, final long index, final long offset) {
-        soProducerIndex(index + 1);// this ensures atomic write of long on 32bit platforms
         soElement(buffer, offset, e);// StoreStore
+        soProducerIndex(index + 1);// this ensures atomic write of long on 32bit platforms
         return true;
     }
 
@@ -144,11 +144,11 @@ private void resize(final E[] oldBuffer, final long currIndex, final long offset
         final E[] newBuffer = (E[]) new Object[capacity];
         producerBuffer = newBuffer;
         producerLookAhead = currIndex + mask - 1;
-        soProducerIndex(currIndex + 1);// this ensures correctness on 32bit platforms
         soElement(newBuffer, offset, e);// StoreStore
         soNext(oldBuffer, newBuffer);
         soElement(oldBuffer, offset, HAS_NEXT); // new buffer is visible after element is
                                                                  // inserted
+        soProducerIndex(currIndex + 1);// this ensures correctness on 32bit platforms
     }
 
     private void soNext(E[] curr, E[] next) {
@@ -174,8 +174,8 @@ public final E poll() {
         final Object e = lvElement(buffer, offset);// LoadLoad
         boolean isNextBuffer = e == HAS_NEXT;
         if (null != e && !isNextBuffer) {
-            soConsumerIndex(index + 1);// this ensures correctness on 32bit platforms
             soElement(buffer, offset, null);// StoreStore
+            soConsumerIndex(index + 1);// this ensures correctness on 32bit platforms
             return (E) e;
         } else if (isNextBuffer) {
             return newBufferPoll(lvNext(buffer), index, mask);
@@ -192,8 +192,8 @@ private E newBufferPoll(E[] nextBuffer, final long index, final long mask) {
         if (null == n) {
             return null;
         } else {
-            soConsumerIndex(index + 1);// this ensures correctness on 32bit platforms
             soElement(nextBuffer, offsetInNew, null);// StoreStore
+            soConsumerIndex(index + 1);// this ensures correctness on 32bit platforms
             return n;
         }
     }
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchTest.java b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
index 836192d3e6..ae85d48864 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
@@ -22,7 +22,7 @@
 import java.lang.ref.WeakReference;
 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;
@@ -32,6 +32,7 @@
 import rx.Observer;
 import rx.exceptions.*;
 import rx.functions.*;
+import rx.internal.util.UtilityFunctions;
 import rx.observers.TestSubscriber;
 import rx.schedulers.*;
 import rx.subjects.PublishSubject;
@@ -880,4 +881,30 @@ public void call(Throwable e) {
             }
         }
     }
+    
+    @Test
+    public void asyncInner() throws Throwable {
+        for (int i = 0; i < 100; i++) {
+            
+            final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
+            
+            Observable.just(Observable.range(1, 1000 * 1000).subscribeOn(Schedulers.computation()))
+            .switchMap(UtilityFunctions.<Observable<Integer>>identity())
+            .observeOn(Schedulers.computation())
+            .ignoreElements()
+            .timeout(5, TimeUnit.SECONDS)
+            .toBlocking()
+            .subscribe(Actions.empty(), new Action1<Throwable>() {
+                @Override
+                public void call(Throwable e) {
+                    error.set(e);
+                }
+            });
+            
+            Throwable ex = error.get();
+            if (ex != null) {
+                throw ex;
+            }
+        }
+    }
 }

From 4e5f6aae88a0993d528077dce3df19c630d825d0 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 15 Jun 2016 23:53:14 +0200
Subject: [PATCH 049/263] 1.x: ReplaySubject now supports backpressure (#3918)

---
 src/main/java/rx/subjects/ReplaySubject.java  | 1753 +++++++++--------
 .../java/rx/subjects/ReplaySubjectTest.java   |  188 +-
 2 files changed, 1066 insertions(+), 875 deletions(-)

diff --git a/src/main/java/rx/subjects/ReplaySubject.java b/src/main/java/rx/subjects/ReplaySubject.java
index f1b693dc9a..d6d9351a8b 100644
--- a/src/main/java/rx/subjects/ReplaySubject.java
+++ b/src/main/java/rx/subjects/ReplaySubject.java
@@ -16,22 +16,16 @@
 package rx.subjects;
 
 import java.lang.reflect.Array;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.*;
 
+import rx.*;
 import rx.Observer;
-import rx.Scheduler;
 import rx.annotations.Beta;
 import rx.exceptions.Exceptions;
-import rx.functions.Action1;
-import rx.functions.Func1;
-import rx.internal.operators.NotificationLite;
-import rx.internal.util.UtilityFunctions;
-import rx.schedulers.Timestamped;
-import rx.subjects.ReplaySubject.NodeList.Node;
-import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
+import rx.internal.operators.BackpressureUtils;
+import rx.internal.util.RxJavaPluginUtils;
 
 /**
  * Subject that buffers all items it observes and replays them to any {@link Observer} that subscribes.
@@ -91,69 +85,12 @@ public static <T> ReplaySubject<T> create() {
      * @return the created subject
      */
     public static <T> ReplaySubject<T> create(int capacity) {
-        final UnboundedReplayState<T> state = new UnboundedReplayState<T>(capacity);
-        SubjectSubscriptionManager<T> ssm = new SubjectSubscriptionManager<T>();
-        ssm.onStart = new Action1<SubjectObserver<T>>() {
-            @Override
-            public void call(SubjectObserver<T> o) {
-                // replay history for this observer using the subscribing thread
-                int lastIndex = state.replayObserverFromIndex(0, o);
-
-                // now that it is caught up add to observers
-                o.index(lastIndex);
-            }
-        };
-        ssm.onAdded = new Action1<SubjectObserver<T>>() {
-            @Override
-            public void call(SubjectObserver<T> o) {
-                synchronized (o) {
-                    if (!o.first || o.emitting) {
-                        return;
-                    }
-                    o.first = false;
-                    o.emitting = true;
-                }
-                boolean skipFinal = false;
-                try {
-                    //noinspection UnnecessaryLocalVariable - Avoid re-read from outside this scope
-                    final UnboundedReplayState<T> localState = state;
-                    for (;;) {
-                        int idx = o.<Integer>index();
-                        int sidx = localState.get();
-                        if (idx != sidx) {
-                            Integer j = localState.replayObserverFromIndex(idx, o);
-                            o.index(j);
-                        }
-                        synchronized (o) {
-                            if (sidx == localState.get()) {
-                                o.emitting = false;
-                                skipFinal = true;
-                                break;
-                            }
-                        }
-                    }
-                } finally {
-                    if (!skipFinal) {
-                        synchronized (o) {
-                            o.emitting = false;
-                        }
-                    }
-                }
-            }
-        };
-        ssm.onTerminated = new Action1<SubjectObserver<T>>() {
-            @Override
-            public void call(SubjectObserver<T> o) {
-                Integer idx = o.index();
-                if (idx == null) {
-                    idx = 0;
-                }
-                // we will finish replaying if there is anything left
-                state.replayObserverFromIndex(idx, o);
-            }
-        };
-        
-        return new ReplaySubject<T>(ssm, ssm, state);
+        if (capacity <= 0) {
+            throw new IllegalArgumentException("capacity > 0 required but it was " + capacity);
+        }
+        ReplayBuffer<T> buffer = new ReplayUnboundedBuffer<T>(capacity);
+        ReplayState<T> state = new ReplayState<T>(buffer);
+        return new ReplaySubject<T>(state);
     }
     /**
      * Creates an unbounded replay subject with the bounded-implementation for testing purposes.
@@ -169,12 +106,9 @@ public void call(SubjectObserver<T> o) {
      * @return the created subject
      */
     /* public */ static <T> ReplaySubject<T> createUnbounded() {
-        final BoundedState<T> state = new BoundedState<T>(
-            new EmptyEvictionPolicy(),
-            UtilityFunctions.identity(),
-            UtilityFunctions.identity()
-        );
-        return createWithState(state, new DefaultOnAdd<T>(state));
+        ReplayBuffer<T> buffer = new ReplaySizeBoundBuffer<T>(Integer.MAX_VALUE);
+        ReplayState<T> state = new ReplayState<T>(buffer);
+        return new ReplaySubject<T>(state);
     }
     /**
      * Creates a size-bounded replay subject.
@@ -197,12 +131,9 @@ public void call(SubjectObserver<T> o) {
      * @return the created subject
      */
     public static <T> ReplaySubject<T> createWithSize(int size) {
-        final BoundedState<T> state = new BoundedState<T>(
-            new SizeEvictionPolicy(size),
-            UtilityFunctions.identity(),
-            UtilityFunctions.identity()
-        );
-        return createWithState(state, new DefaultOnAdd<T>(state));
+        ReplayBuffer<T> buffer = new ReplaySizeBoundBuffer<T>(size);
+        ReplayState<T> state = new ReplayState<T>(buffer);
+        return new ReplaySubject<T>(state);
     }
     /**
      * Creates a time-bounded replay subject.
@@ -237,12 +168,7 @@ public static <T> ReplaySubject<T> createWithSize(int size) {
      * @return the created subject
      */
     public static <T> ReplaySubject<T> createWithTime(long time, TimeUnit unit, final Scheduler scheduler) {
-        final BoundedState<T> state = new BoundedState<T>(
-                new TimeEvictionPolicy(unit.toMillis(time), scheduler),
-                new AddTimestamped(scheduler),
-                new RemoveTimestamped()
-        );
-        return createWithState(state, new TimedOnAdd<T>(state, scheduler));
+        return createWithTimeAndSize(time, unit, Integer.MAX_VALUE, scheduler);
     }
     /**
      * Creates a time- and size-bounded replay subject.
@@ -279,904 +205,1077 @@ public static <T> ReplaySubject<T> createWithTime(long time, TimeUnit unit, fina
      * @return the created subject
      */
     public static <T> ReplaySubject<T> createWithTimeAndSize(long time, TimeUnit unit, int size, final Scheduler scheduler) {
-        final BoundedState<T> state = new BoundedState<T>(
-                new PairEvictionPolicy(
-                        new SizeEvictionPolicy(size),
-                        new TimeEvictionPolicy(unit.toMillis(time), scheduler)
-                ),
-                new AddTimestamped(scheduler),
-                new RemoveTimestamped()
-        );
-        return createWithState(state, new TimedOnAdd<T>(state, scheduler));
-    }
-    /**
-     * Creates a bounded replay subject with the given state shared between the subject and the
-     * {@link OnSubscribe} functions.
-     *
-     * @param <T>
-     *          the type of items observed and emitted by the Subject
-     * @param state
-     *          the shared state
-     * @return the created subject
-     */
-    static <T> ReplaySubject<T> createWithState(final BoundedState<T> state,
-            Action1<SubjectObserver<T>> onStart) {
-        SubjectSubscriptionManager<T> ssm = new SubjectSubscriptionManager<T>();
-        ssm.onStart = onStart;
-        ssm.onAdded = new Action1<SubjectObserver<T>>() {
-            @Override
-            public void call(SubjectObserver<T> o) {
-                synchronized (o) {
-                    if (!o.first || o.emitting) {
-                        return;
-                    }
-                    o.first = false;
-                    o.emitting = true;
-                }
-                boolean skipFinal = false;
-                try {
-                    for (;;) {
-                        NodeList.Node<Object> idx = o.index();
-                        NodeList.Node<Object> sidx = state.tail();
-                        if (idx != sidx) {
-                            NodeList.Node<Object> j = state.replayObserverFromIndex(idx, o);
-                            o.index(j);
-                        }
-                        synchronized (o) {
-                            if (sidx == state.tail()) {
-                                o.emitting = false;
-                                skipFinal = true;
-                                break;
-                            }
-                        }
-                    }
-                } finally {
-                    if (!skipFinal) {
-                        synchronized (o) {
-                            o.emitting = false;
-                        }
-                    }
-                }
-            }
-        };
-        ssm.onTerminated = new Action1<SubjectObserver<T>>() {
-
-            @Override
-            public void call(SubjectObserver<T> t1) {
-                NodeList.Node<Object> l = t1.index();
-                if (l == null) {
-                    l = state.head();
-                }
-                state.replayObserverFromIndex(l, t1);
-            }
-
-        };
-        
-        return new ReplaySubject<T>(ssm, ssm, state);
+        ReplayBuffer<T> buffer = new ReplaySizeAndTimeBoundBuffer<T>(size, unit.toMillis(time), scheduler);
+        ReplayState<T> state = new ReplayState<T>(buffer);
+        return new ReplaySubject<T>(state);
     }
 
     /** The state storing the history and the references. */
-    final ReplayState<T, ?> state;
-    /** The manager of subscribers. */
-    final SubjectSubscriptionManager<T> ssm;
-    ReplaySubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> ssm, ReplayState<T, ?> state) {
-        super(onSubscribe);
-        this.ssm = ssm;
+    final ReplayState<T> state;
+
+    ReplaySubject(ReplayState<T> state) {
+        super(state);
         this.state = state;
     }
     
     @Override
     public void onNext(T t) {
-        if (ssm.active) {
-            state.next(t);
-            for (SubjectSubscriptionManager.SubjectObserver<? super T> o : ssm.observers()) {
-                if (caughtUp(o)) {
-                    o.onNext(t);
-                }
-            }
-        }
+        state.onNext(t);
     }
     
     @Override
     public void onError(final Throwable e) {
-        if (ssm.active) {
-            state.error(e);
-            List<Throwable> errors = null;
-            for (SubjectObserver<? super T> o : ssm.terminate(NotificationLite.instance().error(e))) {
-                try {
-                    if (caughtUp(o)) {
-                        o.onError(e);
-                    }
-                } catch (Throwable e2) {
-                    if (errors == null) {
-                        errors = new ArrayList<Throwable>();
-                    }
-                    errors.add(e2);
-                }
-            }
-
-            Exceptions.throwIfAny(errors);
-        }
+        state.onError(e);
     }
     
     @Override
     public void onCompleted() {
-        if (ssm.active) {
-            state.complete();
-            for (SubjectObserver<? super T> o : ssm.terminate(NotificationLite.instance().completed())) {
-                if (caughtUp(o)) {
-                    o.onCompleted();
-                }
-            }
-        }
+        state.onCompleted();
     }
     /**
      * @return Returns the number of subscribers.
      */
     /* Support test. */int subscriberCount() {
-        return ssm.get().observers.length;
+        return state.get().length;
     }
 
     @Override
     public boolean hasObservers() {
-        return ssm.observers().length > 0;
+        return state.get().length != 0;
     }
 
-    private boolean caughtUp(SubjectObserver<? super T> o) {
-        if (!o.caughtUp) {
-            if (state.replayObserver(o)) {
-                o.caughtUp = true;
-                o.index(null); // once caught up, no need for the index anymore
-            }
-            return false;
-        } else {
-            // it was caught up so proceed the "raw route"
-            return true;
+    /**
+     * Check if the Subject has terminated with an exception.
+     * @return true if the subject has received a throwable through {@code onError}.
+     */
+    @Beta
+    public boolean hasThrowable() {
+        return state.isTerminated() && state.buffer.error() != null;
+    }
+    /**
+     * Check if the Subject has terminated normally.
+     * @return true if the subject completed normally via {@code onCompleted}
+     */
+    @Beta
+    public boolean hasCompleted() {
+        return state.isTerminated() && state.buffer.error() == null;
+    }
+    /**
+     * Returns the Throwable that terminated the Subject.
+     * @return the Throwable that terminated the Subject or {@code null} if the
+     * subject hasn't terminated yet or it terminated normally.
+     */
+    @Beta
+    public Throwable getThrowable() {
+        if (state.isTerminated()) {
+            return state.buffer.error();
         }
+        return null;
+    }
+    /**
+     * Returns the current number of items (non-terminal events) available for replay.
+     * @return the number of items available
+     */
+    @Beta
+    public int size() {
+        return state.buffer.size();
+    }
+    /**
+     * @return true if the Subject holds at least one non-terminal event available for replay
+     */
+    @Beta
+    public boolean hasAnyValue() {
+        return !state.buffer.isEmpty();
+    }
+    @Beta
+    public boolean hasValue() {
+        return hasAnyValue();
+    }
+    /**
+     * Returns a snapshot of the currently buffered non-terminal events into 
+     * the provided {@code a} array or creates a new array if it has not enough capacity.
+     * @param a the array to fill in
+     * @return the array {@code a} if it had enough capacity or a new array containing the available values 
+     */
+    @Beta
+    public T[] getValues(T[] a) {
+        return state.buffer.toArray(a);
     }
     
-    // *********************
-    // State implementations
-    // *********************
+    /** An empty array to trigger getValues() to return a new array. */
+    private static final Object[] EMPTY_ARRAY = new Object[0];
     
     /**
-     * The unbounded replay state.
-     * @param <T> the input and output type
+     * Returns a snapshot of the currently buffered non-terminal events.
+     * <p>The operation is threadsafe.
+     *
+     * @return a snapshot of the currently buffered non-terminal events.
+     * @since (If this graduates from being an Experimental class method, replace this parenthetical with the release number)
      */
-    static final class UnboundedReplayState<T> extends AtomicInteger implements ReplayState<T, Integer> {
-        private final NotificationLite<T> nl = NotificationLite.instance();
-        /** The buffer. */
-        private final ArrayList<Object> list;
-        /** The termination flag. */
-        private volatile boolean terminated;
-        public UnboundedReplayState(int initialCapacity) {
-            list = new ArrayList<Object>(initialCapacity);
-        }
-
-        @Override
-        public void next(T n) {
-            if (!terminated) {
-                list.add(nl.next(n));
-                getAndIncrement(); // release index
-            }
+    @SuppressWarnings("unchecked")
+    @Beta
+    public Object[] getValues() {
+        T[] r = getValues((T[])EMPTY_ARRAY);
+        if (r == EMPTY_ARRAY) {
+            return new Object[0]; // don't leak the default empty array.
         }
+        return r;
+    }
+    
+    @Beta
+    public T getValue() {
+        return state.buffer.last();
+    }
+    
+    /**
+     * Holds onto the array of Subscriber-wrapping ReplayProducers and
+     * the buffer that holds values to be replayed; it manages
+     * subscription and signal dispatching.
+     *
+     * @param <T> the value type
+     */
+    static final class ReplayState<T> 
+    extends AtomicReference<ReplayProducer<T>[]>
+    implements OnSubscribe<T>, Observer<T> {
 
-        public void accept(Observer<? super T> o, int idx) {
-            nl.accept(o, list.get(idx));
-        }
+        /** */
+        private static final long serialVersionUID = 5952362471246910544L;
         
-        @Override
-        public void complete() {
-            if (!terminated) {
-                terminated = true;
-                list.add(nl.completed());
-                getAndIncrement(); // release index
-            }
+        final ReplayBuffer<T> buffer;
+        
+        @SuppressWarnings("rawtypes")
+        static final ReplayProducer[] EMPTY = new ReplayProducer[0];
+        @SuppressWarnings("rawtypes")
+        static final ReplayProducer[] TERMINATED = new ReplayProducer[0];
+        
+        @SuppressWarnings("unchecked")
+        public ReplayState(ReplayBuffer<T> buffer) {
+            this.buffer = buffer;
+            lazySet(EMPTY);
         }
+        
         @Override
-        public void error(Throwable e) {
-            if (!terminated) {
-                terminated = true;
-                list.add(nl.error(e));
-                getAndIncrement(); // release index
+        public void call(Subscriber<? super T> t) {
+            ReplayProducer<T> rp = new ReplayProducer<T>(t, this);
+            t.add(rp);
+            t.setProducer(rp);
+            
+            if (add(rp)) {
+                if (rp.isUnsubscribed()) {
+                    remove(rp);
+                    return;
+                }
             }
+            buffer.drain(rp);
         }
-
-        @Override
-        public boolean terminated() {
-            return terminated;
-        }
-
-        @Override
-        public boolean replayObserver(SubjectObserver<? super T> observer) {
-            
-            synchronized (observer) {
-                observer.first = false;
-                if (observer.emitting) {
+        
+        boolean add(ReplayProducer<T> rp) {
+            for (;;) {
+                ReplayProducer<T>[] a = get();
+                if (a == TERMINATED) {
                     return false;
                 }
-            }
-            
-            Integer lastEmittedLink = observer.index();
-            if (lastEmittedLink != null) {
-                int l = replayObserverFromIndex(lastEmittedLink, observer);
-                observer.index(l);
-                return true;
-            } else {
-                throw new IllegalStateException("failed to find lastEmittedLink for: " + observer);
+                
+                int n = a.length;
+                
+                @SuppressWarnings("unchecked")
+                ReplayProducer<T>[] b = new ReplayProducer[n + 1];
+                System.arraycopy(a, 0, b, 0, n);
+                b[n] = rp;
+                
+                if (compareAndSet(a, b)) {
+                    return true;
+                }
             }
         }
-
-        @Override
-        public Integer replayObserverFromIndex(Integer idx, SubjectObserver<? super T> observer) {
-            int i = idx;
-            while (i < get()) {
-                accept(observer, i);
-                i++;
+        
+        @SuppressWarnings("unchecked")
+        void remove(ReplayProducer<T> rp) {
+            for (;;) {
+                ReplayProducer<T>[] a = get();
+                if (a == TERMINATED || a == EMPTY) {
+                    return;
+                }
+                
+                int n = a.length;
+                
+                int j = -1;
+                for (int i = 0; i < n; i++) {
+                    if (a[i] == rp) {
+                        j = i;
+                        break;
+                    }
+                }
+                
+                if (j < 0) {
+                    return;
+                }
+                
+                ReplayProducer<T>[] b;
+                if (n == 1) {
+                    b = EMPTY;
+                } else {
+                    b = new ReplayProducer[n - 1];
+                    System.arraycopy(a, 0, b, 0, j);
+                    System.arraycopy(a, j + 1, b, j, n - j - 1);
+                }
+                if (compareAndSet(a, b)) {
+                    return;
+                }
             }
-
-            return i;
         }
 
         @Override
-        public Integer replayObserverFromIndexTest(Integer idx, SubjectObserver<? super T> observer, long now) {
-            return replayObserverFromIndex(idx, observer);
-        }
-        
-        @Override
-        public int size() {
-            int idx = get(); // acquire
-            if (idx > 0) {
-                Object o = list.get(idx - 1);
-                if (nl.isCompleted(o) || nl.isError(o)) {
-                    return idx - 1; // do not report a terminal event as part of size
+        public void onNext(T t) {
+            ReplayBuffer<T> b = buffer;
+            
+            b.next(t);
+            for (ReplayProducer<T> rp : get()) {
+                if (rp.caughtUp) {
+                    rp.actual.onNext(t);
+                } else {
+                    if (b.drain(rp)) {
+                        rp.caughtUp = true;
+                        rp.node = null;
+                    }
                 }
             }
-            return idx;
         }
-        @Override
-        public boolean isEmpty() {
-            return size() == 0;
-        }
-        @Override
+
         @SuppressWarnings("unchecked")
-        public T[] toArray(T[] a) {
-            int s = size();
-            if (s > 0) {
-                if (s > a.length) {
-                    a = (T[])Array.newInstance(a.getClass().getComponentType(), s);
-                }
-                for (int i = 0; i < s; i++) {
-                    a[i] = (T)list.get(i);
-                }
-                if (a.length > s) {
-                    a[s] = null;
+        @Override
+        public void onError(Throwable e) {
+            ReplayBuffer<T> b = buffer;
+            
+            b.error(e);
+            List<Throwable> errors = null;
+            for (ReplayProducer<T> rp : getAndSet(TERMINATED)) {
+                try {
+                    if (rp.caughtUp) {
+                        rp.actual.onError(e);
+                    } else {
+                        if (b.drain(rp)) {
+                            rp.caughtUp = true;
+                            rp.node = null;
+                        }
+                    }
+                } catch (Throwable ex) {
+                    if (errors == null) {
+                        errors = new ArrayList<Throwable>();
+                    }
+                    errors.add(ex);
                 }
-            } else
-            if (a.length > 0) {
-                a[0] = null;
             }
-            return a;
+            
+            Exceptions.throwIfAny(errors);
         }
+
+        @SuppressWarnings("unchecked")
         @Override
-        public T latest() {
-            int idx = get();
-            if (idx > 0) {
-                Object o = list.get(idx - 1);
-                if (nl.isCompleted(o) || nl.isError(o)) {
-                    if (idx > 1) {
-                        return nl.getValue(list.get(idx - 2));
+        public void onCompleted() {
+            ReplayBuffer<T> b = buffer;
+            
+            b.complete();
+            for (ReplayProducer<T> rp : getAndSet(TERMINATED)) {
+                if (rp.caughtUp) {
+                    rp.actual.onCompleted();
+                } else {
+                    if (b.drain(rp)) {
+                        rp.caughtUp = true;
+                        rp.node = null;
                     }
-                    return null;
                 }
-                return nl.getValue(o);
             }
-            return null;
+        }
+        
+        
+        boolean isTerminated() {
+            return get() == TERMINATED;
         }
     }
     
+    /**
+     * The base interface for buffering signals to be replayed to individual
+     * Subscribers.
+     *
+     * @param <T> the value type
+     */
+    interface ReplayBuffer<T> {
+        
+        void next(T t);
+        
+        void error(Throwable e);
+        
+        void complete();
+        
+        boolean drain(ReplayProducer<T> rp);
+        
+        boolean isComplete();
+        
+        Throwable error();
+        
+        T last();
+        
+        int size();
+        
+        boolean isEmpty();
+        
+        T[] toArray(T[] a);
+    }
     
-    /** 
-     * The bounded replay state. 
-     * @param <T> the input and output type
+    /**
+     * An unbounded ReplayBuffer implementation that uses linked-arrays
+     * to avoid copy-on-grow situation with ArrayList.
+     *
+     * @param <T> the value type
      */
-    static final class BoundedState<T> implements ReplayState<T, NodeList.Node<Object>> {
-        final NodeList<Object> list;
-        final EvictionPolicy evictionPolicy;
-        final Func1<Object, Object> enterTransform;
-        final Func1<Object, Object> leaveTransform;
-        final NotificationLite<T> nl = NotificationLite.instance();
-        volatile boolean terminated;
-        volatile NodeList.Node<Object> tail;
+    static final class ReplayUnboundedBuffer<T> implements ReplayBuffer<T> {
+        final int capacity;
+        
+        volatile int size;
+        
+        final Object[] head;
         
-        public BoundedState(EvictionPolicy evictionPolicy, Func1<Object, Object> enterTransform, 
-                Func1<Object, Object> leaveTransform) {
-            this.list = new NodeList<Object>();
-            this.tail = list.tail;
-            this.evictionPolicy = evictionPolicy;
-            this.enterTransform = enterTransform;
-            this.leaveTransform = leaveTransform;
+        Object[] tail;
+        
+        int tailIndex;
+        
+        volatile boolean done;
+        Throwable error;
+        
+        public ReplayUnboundedBuffer(int capacity) {
+            this.capacity = capacity;
+            this.tail = this.head = new Object[capacity + 1];
         }
+
         @Override
-        public void next(T value) {
-            if (!terminated) {
-                list.addLast(enterTransform.call(nl.next(value)));
-                evictionPolicy.evict(list);
-                tail = list.tail;
+        public void next(T t) {
+            if (done) {
+                return;
             }
-        }
-        @Override
-        public void complete() {
-            if (!terminated) {
-                terminated = true;
-                list.addLast(enterTransform.call(nl.completed()));
-                evictionPolicy.evictFinal(list);
-                tail = list.tail;
+            int i = tailIndex;
+            Object[] a = tail;
+            if (i == a.length - 1) {
+                Object[] b = new Object[a.length];
+                b[0] = t;
+                tailIndex = 1;
+                a[i] = b;
+                tail = b;
+            } else {
+                a[i] = t;
+                tailIndex = i + 1;
             }
+            size++;
             
         }
+
         @Override
         public void error(Throwable e) {
-            if (!terminated) {
-                terminated = true;
-                list.addLast(enterTransform.call(nl.error(e)));
-                // don't evict the terminal value
-                evictionPolicy.evictFinal(list);
-                tail = list.tail;
-            }
-        }
-        public void accept(Observer<? super T> o, NodeList.Node<Object> node) {
-            nl.accept(o, leaveTransform.call(node.value));
-        }
-        /**
-         * Accept only non-stale nodes.
-         * @param o the target observer
-         * @param node the node to accept or reject
-         * @param now the current time
-         */
-        public void acceptTest(Observer<? super T> o, NodeList.Node<Object> node, long now) {
-            Object v = node.value;
-            if (!evictionPolicy.test(v, now)) {
-                nl.accept(o, leaveTransform.call(v));
-            }
-        }
-        public Node<Object> head() {
-            return list.head;
-        }
-        public Node<Object> tail() {
-            return tail;
-        }
-        @Override
-        public boolean replayObserver(SubjectObserver<? super T> observer) {
-            synchronized (observer) {
-                observer.first = false;
-                if (observer.emitting) {
-                    return false;
-                }
+            if (done) {
+                RxJavaPluginUtils.handleException(e);
+                return;
             }
-            
-            NodeList.Node<Object> lastEmittedLink = observer.index();
-            NodeList.Node<Object> l = replayObserverFromIndex(lastEmittedLink, observer);
-            observer.index(l);
-            return true;
+            error = e;
+            done = true;
         }
 
         @Override
-        public NodeList.Node<Object> replayObserverFromIndex(
-                NodeList.Node<Object> l, SubjectObserver<? super T> observer) {
-            while (l != tail()) {
-                accept(observer, l.next);
-                l = l.next;
-            }
-            return l;
-        }
-        @Override
-        public NodeList.Node<Object> replayObserverFromIndexTest(
-                NodeList.Node<Object> l, SubjectObserver<? super T> observer, long now) {
-            while (l != tail()) {
-                acceptTest(observer, l.next, now);
-                l = l.next;
-            }
-            return l;
+        public void complete() {
+            done = true;
         }
 
         @Override
-        public boolean terminated() {
-            return terminated;
-        }
-        
-        @Override
-        public int size() {
-            int size = 0;
-            NodeList.Node<Object> l = head();
-            NodeList.Node<Object> next = l.next;
-            while (next != null) {
-                size++;
-                l = next;
-                next = next.next;
+        public boolean drain(ReplayProducer<T> rp) {
+            if (rp.getAndIncrement() != 0) {
+                return false;
             }
-            if (l.value != null) {
-                Object value = leaveTransform.call(l.value);
-                if (value != null && (nl.isError(value) || nl.isCompleted(value))) {
-                    return size - 1;
+            
+            int missed = 1;
+            
+            final Subscriber<? super T> a = rp.actual;
+            final int n = capacity;
+            
+            for (;;) {
+                
+                long r = rp.requested.get();
+                long e = 0L;
+                
+                Object[] node = (Object[])rp.node;
+                if (node == null) {
+                    node = head;
+                }
+                int tailIndex = rp.tailIndex;
+                int index = rp.index;
+                
+                while (e != r) {
+                    if (a.isUnsubscribed()) {
+                        rp.node = null;
+                        return false;
+                    }
+                    
+                    boolean d = done;
+                    boolean empty = index == size;
+
+                    if (d && empty) {
+                        rp.node = null;
+                        Throwable ex = error;
+                        if (ex != null) {
+                            a.onError(ex);
+                        } else {
+                            a.onCompleted();
+                        }
+                        return false;
+                    }
+                    
+                    if (empty) {
+                        break;
+                    }
+                    
+                    if (tailIndex == n) {
+                        node = (Object[])node[tailIndex];
+                        tailIndex = 0;
+                    }
+                    
+                    @SuppressWarnings("unchecked")
+                    T v = (T)node[tailIndex];
+                    
+                    a.onNext(v);
+                    
+                    e++;
+                    tailIndex++;
+                    index++;
+                }
+                
+                if (e == r) {
+                    if (a.isUnsubscribed()) {
+                        rp.node = null;
+                        return false;
+                    }
+                    
+                    boolean d = done;
+                    boolean empty = index == size;
+
+                    if (d && empty) {
+                        rp.node = null;
+                        Throwable ex = error;
+                        if (ex != null) {
+                            a.onError(ex);
+                        } else {
+                            a.onCompleted();
+                        }
+                        return false;
+                    }
+                }
+                
+                if (e != 0L) {
+                    if (r != Long.MAX_VALUE) {
+                        BackpressureUtils.produced(rp.requested, e);
+                    }
+                }
+                
+                rp.index = index;
+                rp.tailIndex = tailIndex;
+                rp.node = node;
+                
+                missed = rp.addAndGet(-missed);
+                if (missed == 0) {
+                    return r == Long.MAX_VALUE;
                 }
             }
-            return size;
         }
+
         @Override
-        public boolean isEmpty() {
-            NodeList.Node<Object> l = head();
-            NodeList.Node<Object> next = l.next;
-            if (next == null) {
-                return true;
-            }
-            Object value = leaveTransform.call(next.value);
-            return nl.isError(value) || nl.isCompleted(value);
+        public boolean isComplete() {
+            return done;
         }
+
         @Override
-        @SuppressWarnings("unchecked")
-        public T[] toArray(T[] a) {
-            List<T> list = new ArrayList<T>();
-            NodeList.Node<Object> next = head().next;
-            while (next != null) {
-                Object o = leaveTransform.call(next.value);
+        public Throwable error() {
+            return error;
+        }
 
-                if (next.next == null && (nl.isError(o) || nl.isCompleted(o))) {
-                    break;
-                } else {
-                    list.add((T)o);
-                }
-                next = next.next;
+        @SuppressWarnings("unchecked")
+        @Override
+        public T last() {
+            // we don't have a volatile read on tail and tailIndex
+            // so we have to traverse the linked structure up until
+            // we read size / capacity nodes and index into the array
+            // via size % capacity
+            int s = size;
+            if (s == 0) {
+                return null;
             }
-            return list.toArray(a);
+            Object[] h = head;
+            int n = capacity;
+            
+            while (s >= n) {
+                h = (Object[])h[n];
+                s -= n;
+            }
+            
+            return (T)h[s - 1];
         }
+
         @Override
-        public T latest() {
-            Node<Object> h = head().next;
-            if (h == null) {
-                return null;
+        public int size() {
+            return size;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return size == 0;
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public T[] toArray(T[] a) {
+            int s = size;
+            if (a.length < s) {
+                a = (T[])Array.newInstance(a.getClass().getComponentType(), s);
             }
-            Node<Object> p = null;
-            while (h != tail()) {
-                p = h;
-                h = h.next;
+
+            Object[] h = head;
+            int n = capacity;
+
+            int j = 0;
+
+            while (j + n < s) {
+                System.arraycopy(h, 0, a, j, n);
+                j += n;
+                h = (Object[])h[n];
             }
-            Object value = leaveTransform.call(h.value);
-            if (nl.isError(value) || nl.isCompleted(value)) {
-                if (p != null) {
-                    value = leaveTransform.call(p.value);
-                    return nl.getValue(value);
-                }
-                return null;
+            
+            System.arraycopy(h, 0, a, j, s - j);
+            
+            if (a.length > s) {
+                a[s] = null;
             }
-            return nl.getValue(value);
+            
+            return a;
         }
     }
     
-    // **************
-    // API interfaces
-    // **************
-    
-    /**
-     * General API for replay state management.
-     * @param <T> the input and output type
-     * @param <I> the index type
-     */
-    interface ReplayState<T, I> {
-        /** @return true if the subject has reached a terminal state. */
-        boolean terminated();
-        /**
-         * Replay contents to the given observer.
-         * @param observer the receiver of events
-         * @return true if the subject has caught up
-         */
-        boolean replayObserver(SubjectObserver<? super T> observer);
-        /**
-         * Replay the buffered values from an index position and return a new index
-         * @param idx the current index position
-         * @param observer the receiver of events
-         * @return the new index position
-         */
-        I replayObserverFromIndex(
-                I idx, SubjectObserver<? super T> observer);
-        /**
-         * Replay the buffered values from an index position while testing for stale entries and return a new index
-         * @param idx the current index position
-         * @param observer the receiver of events
-         * @return the new index position
-         */
-        I replayObserverFromIndexTest(
-                I idx, SubjectObserver<? super T> observer, long now);
-        /**
-         * Add an OnNext value to the buffer
-         * @param value the value to add
-         */
-        void next(T value);
-        /**
-         * Add an OnError exception and terminate the subject
-         * @param e the exception to add
-         */
-        void error(Throwable e);
-        /**
-         * Add an OnCompleted exception and terminate the subject
-         */
-        void complete();
-        /**
-         * @return the number of non-terminal values in the replay buffer.
-         */
-        int size();
-        /**
-         * @return true if the replay buffer is empty of non-terminal values
-         */
-        boolean isEmpty();
+    static final class ReplaySizeBoundBuffer<T> implements ReplayBuffer<T> {
+        final int limit;
         
-        /**
-         * Copy the current values (minus any terminal value) from the buffer into the array
-         * or create a new array if there isn't enough room.
-         * @param a the array to fill in
-         * @return the array or a new array containing the current values
-         */
-        T[] toArray(T[] a);
-        /**
-         * Returns the latest value that has been buffered or null if no such value
-         * present.
-         * @return the latest value buffered or null if none
-         */
-        T latest();
-    }
-    
-    /** Interface to manage eviction checking. */
-    interface EvictionPolicy {
-        /**
-         * Subscribe-time checking for stale entries.
-         * @param value the value to test
-         * @param now the current time
-         * @return true if the value may be evicted
-         */
-        boolean test(Object value, long now);
-        /**
-         * Evict values from the list.
-         * @param list the node list
-         */
-        void evict(NodeList<Object> list);
-        /**
-         * Evict values from the list except the very last which is considered
-         * a terminal event
-         * @param list the node list
-         */
-        void evictFinal(NodeList<Object> list);
-    }
+        volatile Node<T> head;
+        
+        Node<T> tail;
 
-    
-    // ************************
-    // Callback implementations
-    // ************************
-    
-    /**
-     * Remove elements from the beginning of the list if the size exceeds some threshold.
-     */
-    static final class SizeEvictionPolicy implements EvictionPolicy {
-        final int maxSize;
+        int size;
+
+        volatile boolean done;
+        Throwable error;
         
-        public SizeEvictionPolicy(int maxSize) {
-            this.maxSize = maxSize;
+        public ReplaySizeBoundBuffer(int limit) {
+            this.limit = limit;
+            Node<T> n = new Node<T>(null);
+            this.tail = n;
+            this.head = n;
         }
-        
+
         @Override
-        public void evict(NodeList<Object> t1) {
-            while (t1.size() > maxSize) {
-                t1.removeFirst();
+        public void next(T value) {
+            Node<T> n = new Node<T>(value);
+            tail.set(n);
+            tail = n;
+            int s = size;
+            if (s == limit) {
+                head = head.get();
+            } else {
+                size = s + 1;
             }
         }
 
         @Override
-        public boolean test(Object value, long now) {
-            return false; // size gets never stale
+        public void error(Throwable ex) {
+            error = ex;
+            done = true;
         }
-        
+
         @Override
-        public void evictFinal(NodeList<Object> t1) {
-            while (t1.size() > maxSize + 1) {
-                t1.removeFirst();
-            }
-        }
-    }
-    /**
-     * Remove elements from the beginning of the list if the Timestamped value is older than
-     * a threshold.
-     */
-    static final class TimeEvictionPolicy implements EvictionPolicy {
-        final long maxAgeMillis;
-        final Scheduler scheduler;
-        
-        public TimeEvictionPolicy(long maxAgeMillis, Scheduler scheduler) {
-            this.maxAgeMillis = maxAgeMillis;
-            this.scheduler = scheduler;
+        public void complete() {
+            done = true;
         }
-        
+
         @Override
-        public void evict(NodeList<Object> t1) {
-            long now = scheduler.now();
-            while (!t1.isEmpty()) {
-                NodeList.Node<Object> n = t1.head.next;
-                if (test(n.value, now)) {
-                    t1.removeFirst();
-                } else {
-                    break;
+        public boolean drain(ReplayProducer<T> rp) {
+            if (rp.getAndIncrement() != 0) {
+                return false;
+            }
+            
+            final Subscriber<? super T> a = rp.actual;
+            
+            int missed = 1;
+            
+            for (;;) {
+                
+                long r = rp.requested.get();
+                long e = 0L;
+                
+                @SuppressWarnings("unchecked")
+                Node<T> node = (Node<T>)rp.node;
+                if (node == null) {
+                    node = head;
+                }
+                
+                while (e != r) {
+                    if (a.isUnsubscribed()) {
+                        rp.node = null;
+                        return false;
+                    }
+                    
+                    boolean d = done;
+                    Node<T> next = node.get();
+                    boolean empty = next == null;
+                    
+                    if (d && empty) {
+                        rp.node = null;
+                        Throwable ex = error;
+                        if (ex != null) {
+                            a.onError(ex);
+                        } else {
+                            a.onCompleted();
+                        }
+                        return false;
+                    }
+                    
+                    if (empty) {
+                        break;
+                    }
+                    
+                    a.onNext(next.value);
+                    
+                    e++;
+                    node = next;
+                }
+                
+                if (e == r) {
+                    if (a.isUnsubscribed()) {
+                        rp.node = null;
+                        return false;
+                    }
+                    
+                    boolean d = done;
+                    boolean empty = node.get() == null;
+                    
+                    if (d && empty) {
+                        rp.node = null;
+                        Throwable ex = error;
+                        if (ex != null) {
+                            a.onError(ex);
+                        } else {
+                            a.onCompleted();
+                        }
+                        return false;
+                    }
+                }
+                
+                if (e != 0L) {
+                    if (r != Long.MAX_VALUE) {
+                        BackpressureUtils.produced(rp.requested, e);
+                    }
+                }
+                
+                rp.node = node;
+                
+                missed = rp.addAndGet(-missed);
+                if (missed == 0) {
+                    return r == Long.MAX_VALUE;
                 }
             }
         }
-        
-        @Override
-        public void evictFinal(NodeList<Object> t1) {
-            long now = scheduler.now();
-            while (t1.size > 1) {
-                NodeList.Node<Object> n = t1.head.next;
-                if (test(n.value, now)) {
-                    t1.removeFirst();
-                } else {
-                    break;
-                }
+
+        static final class Node<T> extends AtomicReference<Node<T>> {
+            /** */
+            private static final long serialVersionUID = 3713592843205853725L;
+            
+            final T value;
+            
+            public Node(T value) {
+                this.value = value;
             }
         }
 
         @Override
-        public boolean test(Object value, long now) {
-            Timestamped<?> ts = (Timestamped<?>)value;
-            return ts.getTimestampMillis() <= now - maxAgeMillis;
+        public boolean isComplete() {
+            return done;
         }
-        
-    }
-    /**
-     * Pairs up two eviction policy callbacks.
-     */
-    static final class PairEvictionPolicy implements EvictionPolicy {
-        final EvictionPolicy first;
-        final EvictionPolicy second;
-        
-        public PairEvictionPolicy(EvictionPolicy first, EvictionPolicy second) {
-            this.first = first;
-            this.second = second;
+
+        @Override
+        public Throwable error() {
+            return error;
         }
-        
+
         @Override
-        public void evict(NodeList<Object> t1) {
-            first.evict(t1);
-            second.evict(t1);
+        public T last() {
+            Node<T> h = head;
+            Node<T> n;
+            while ((n = h.get()) != null) {
+                h = n;
+            }
+            return h.value;
         }
-        
+
         @Override
-        public void evictFinal(NodeList<Object> t1) {
-            first.evictFinal(t1);
-            second.evictFinal(t1);
+        public int size() {
+            int s = 0;
+            Node<T> n = head.get();
+            while (n != null && s != Integer.MAX_VALUE) {
+                n = n.get();
+                s++;
+            }
+            return s;
         }
 
         @Override
-        public boolean test(Object value, long now) {
-            return first.test(value, now) || second.test(value, now);
+        public boolean isEmpty() {
+            return head.get() == null;
+        }
+
+        @Override
+        public T[] toArray(T[] a) {
+            List<T> list = new ArrayList<T>();
+            
+            Node<T> n = head.get();
+            while (n != null) {
+                list.add(n.value);
+                n = n.get();
+            }
+            return list.toArray(a);
         }
+
     }
-    
-    /** Maps the values to Timestamped. */
-    static final class AddTimestamped implements Func1<Object, Object> {
+
+    static final class ReplaySizeAndTimeBoundBuffer<T> implements ReplayBuffer<T> {
+        final int limit;
+        
+        final long maxAgeMillis;
+        
         final Scheduler scheduler;
+        
+        volatile TimedNode<T> head;
+        
+        TimedNode<T> tail;
+
+        int size;
 
-        public AddTimestamped(Scheduler scheduler) {
+        volatile boolean done;
+        Throwable error;
+        
+        public ReplaySizeAndTimeBoundBuffer(int limit, long maxAgeMillis, Scheduler scheduler) {
+            this.limit = limit;
+            TimedNode<T> n = new TimedNode<T>(null, 0L);
+            this.tail = n;
+            this.head = n;
+            this.maxAgeMillis = maxAgeMillis;
             this.scheduler = scheduler;
         }
 
         @Override
-        public Object call(Object t1) {
-            return new Timestamped<Object>(scheduler.now(), t1);
+        public void next(T value) {
+            long now = scheduler.now();
+            
+            TimedNode<T> n = new TimedNode<T>(value, now);
+            tail.set(n);
+            tail = n;
+            
+            now -= maxAgeMillis;
+
+            int s = size;
+            TimedNode<T> h0 = head;
+            TimedNode<T> h = h0;
+            
+            if (s == limit) {
+                h = h.get();
+            } else {
+                s++;
+            }
+            
+            while ((n = h.get()) != null) {
+                if (n.timestamp > now) {
+                    break;
+                }
+                h = n;
+                s--;
+            }
+            
+            size = s;
+            if (h != h0) {
+                head = h;
+            }
         }
-    }
-    /** Maps timestamped values back to raw objects. */
-    static final class RemoveTimestamped implements Func1<Object, Object> {
         @Override
-        @SuppressWarnings("unchecked")
-        public Object call(Object t1) {
-            return ((Timestamped<Object>)t1).getValue();
+        public void error(Throwable ex) {
+            evictFinal();
+            error = ex;
+            done = true;
         }
-    }
-    /**
-     * Default action of simply replaying the buffer on subscribe.
-     * @param <T> the input and output value type
-     */
-    static final class DefaultOnAdd<T> implements Action1<SubjectObserver<T>> {
-        final BoundedState<T> state;
 
-        public DefaultOnAdd(BoundedState<T> state) {
-            this.state = state;
-        }
-        
         @Override
-        public void call(SubjectObserver<T> t1) {
-            NodeList.Node<Object> l = state.replayObserverFromIndex(state.head(), t1);
-            t1.index(l);
+        public void complete() {
+            evictFinal();
+            done = true;
         }
         
-    }
-    /**
-     * Action of replaying non-stale entries of the buffer on subscribe
-     * @param <T> the input and output value
-     */
-    static final class TimedOnAdd<T> implements Action1<SubjectObserver<T>> {
-        final BoundedState<T> state;
-        final Scheduler scheduler;
+        void evictFinal() {
+            long now = scheduler.now() - maxAgeMillis;
+            
+            TimedNode<T> h0 = head;
+            TimedNode<T> h = h0;
+            TimedNode<T> n;
+            
+            while ((n = h.get()) != null) {
+                if (n.timestamp > now) {
+                    break;
+                }
+                h = n;
+            }
+            
+            if (h0 != h) {
+                head = h;
+            }
+        }
 
-        public TimedOnAdd(BoundedState<T> state, Scheduler scheduler) {
-            this.state = state;
-            this.scheduler = scheduler;
+        TimedNode<T> latestHead() {
+            long now = scheduler.now() - maxAgeMillis;
+            TimedNode<T> h = head;
+            TimedNode<T> n;
+            while ((n = h.get()) != null) {
+                if (n.timestamp > now) {
+                    break;
+                }
+                h = n;
+            }
+            return h;
         }
         
         @Override
-        public void call(SubjectObserver<T> t1) {
-            NodeList.Node<Object> l;
-            if (!state.terminated) {
-                // ignore stale entries if still active
-                l = state.replayObserverFromIndexTest(state.head(), t1, scheduler.now());
-            }  else {
-                // accept all if terminated
-                l = state.replayObserverFromIndex(state.head(), t1);
+        public boolean drain(ReplayProducer<T> rp) {
+            if (rp.getAndIncrement() != 0) {
+                return false;
+            }
+            
+            final Subscriber<? super T> a = rp.actual;
+            
+            int missed = 1;
+            
+            for (;;) {
+                
+                long r = rp.requested.get();
+                long e = 0L;
+                
+                @SuppressWarnings("unchecked")
+                TimedNode<T> node = (TimedNode<T>)rp.node;
+                if (node == null) {
+                    node = latestHead();
+                }
+                
+                while (e != r) {
+                    if (a.isUnsubscribed()) {
+                        rp.node = null;
+                        return false;
+                    }
+                    
+                    boolean d = done;
+                    TimedNode<T> next = node.get();
+                    boolean empty = next == null;
+                    
+                    if (d && empty) {
+                        rp.node = null;
+                        Throwable ex = error;
+                        if (ex != null) {
+                            a.onError(ex);
+                        } else {
+                            a.onCompleted();
+                        }
+                        return false;
+                    }
+                    
+                    if (empty) {
+                        break;
+                    }
+                    
+                    a.onNext(next.value);
+                    
+                    e++;
+                    node = next;
+                }
+                
+                if (e == r) {
+                    if (a.isUnsubscribed()) {
+                        rp.node = null;
+                        return false;
+                    }
+                    
+                    boolean d = done;
+                    boolean empty = node.get() == null;
+                    
+                    if (d && empty) {
+                        rp.node = null;
+                        Throwable ex = error;
+                        if (ex != null) {
+                            a.onError(ex);
+                        } else {
+                            a.onCompleted();
+                        }
+                        return false;
+                    }
+                }
+                
+                if (e != 0L) {
+                    if (r != Long.MAX_VALUE) {
+                        BackpressureUtils.produced(rp.requested, e);
+                    }
+                }
+                
+                rp.node = node;
+                
+                missed = rp.addAndGet(-missed);
+                if (missed == 0) {
+                    return r == Long.MAX_VALUE;
+                }
             }
-            t1.index(l);
         }
-        
-    }
-    /**
-     * A singly-linked list with volatile next node pointer.
-     * @param <T> the value type
-     */
-    static final class NodeList<T> {
-        /**
-         * The node containing the value and references to neighbours.
-         * @param <T> the value type
-         */
-        static final class Node<T> {
-            /** The managed value. */
+
+        static final class TimedNode<T> extends AtomicReference<TimedNode<T>> {
+            /** */
+            private static final long serialVersionUID = 3713592843205853725L;
+            
             final T value;
-            /** The hard reference to the next node. */
-            volatile Node<T> next;
-            Node(T value) {
+            
+            final long timestamp;
+            
+            public TimedNode(T value, long timestamp) {
                 this.value = value;
+                this.timestamp = timestamp;
             }
         }
-        /** The head of the list. */
-        final Node<T> head = new Node<T>(null);
-        /** The tail of the list. */
-        Node<T> tail = head;
-        /** The number of elements in the list. */
-        int size;
-        
-        public void addLast(T value) {
-            Node<T> t = tail;
-            Node<T> t2 = new Node<T>(value);
-            t.next = t2;
-            tail = t2;
-            size++;
-        }
-        public T removeFirst() {
-            if (head.next == null) {
-                throw new IllegalStateException("Empty!");
-            }
-            Node<T> t = head.next;
-            head.next = t.next;
-            if (head.next == null) {
-                tail = head;
-            }
-            size--;
-            return t.value;
-        }
-        public boolean isEmpty() {
-            return size == 0;
+
+        @Override
+        public boolean isComplete() {
+            return done;
         }
-        public int size() {
-            return size;
+
+        @Override
+        public Throwable error() {
+            return error;
         }
-        public void clear() {
-            tail = head;
-            size = 0;
+
+        @Override
+        public T last() {
+            TimedNode<T> h = latestHead();
+            TimedNode<T> n;
+            while ((n = h.get()) != null) {
+                h = n;
+            }
+            return h.value;
         }
-    }
-    /** Empty eviction policy. */
-    static final class EmptyEvictionPolicy implements EvictionPolicy {
+
         @Override
-        public boolean test(Object value, long now) {
-            return true;
+        public int size() {
+            int s = 0;
+            TimedNode<T> n = latestHead().get();
+            while (n != null && s != Integer.MAX_VALUE) {
+                n = n.get();
+                s++;
+            }
+            return s;
         }
+
         @Override
-        public void evict(NodeList<Object> list) {
+        public boolean isEmpty() {
+            return latestHead().get() == null;
         }
+
         @Override
-        public void evictFinal(NodeList<Object> list) {
+        public T[] toArray(T[] a) {
+            List<T> list = new ArrayList<T>();
+            
+            TimedNode<T> n = latestHead().get();
+            while (n != null) {
+                list.add(n.value);
+                n = n.get();
+            }
+            return list.toArray(a);
         }
-    }    
-    /**
-     * Check if the Subject has terminated with an exception.
-     * @return true if the subject has received a throwable through {@code onError}.
-     */
-    @Beta
-    public boolean hasThrowable() {
-        NotificationLite<T> nl = ssm.nl;
-        Object o = ssm.getLatest();
-        return nl.isError(o);
-    }
-    /**
-     * Check if the Subject has terminated normally.
-     * @return true if the subject completed normally via {@code onCompleted}
-     */
-    @Beta
-    public boolean hasCompleted() {
-        NotificationLite<T> nl = ssm.nl;
-        Object o = ssm.getLatest();
-        return o != null && !nl.isError(o);
+
     }
+
     /**
-     * Returns the Throwable that terminated the Subject.
-     * @return the Throwable that terminated the Subject or {@code null} if the
-     * subject hasn't terminated yet or it terminated normally.
+     * A producer and subscription implementation that tracks the current
+     * replay position of a particular subscriber.
+     * <p>
+     * The this holds the current work-in-progress indicator used by serializing
+     * replays.
+     * 
+     * @param <T> the value type
      */
-    @Beta
-    public Throwable getThrowable() {
-        NotificationLite<T> nl = ssm.nl;
-        Object o = ssm.getLatest();
-        if (nl.isError(o)) {
-            return nl.getError(o);
+    static final class ReplayProducer<T> 
+    extends AtomicInteger
+    implements Producer, Subscription {
+        /** */
+        private static final long serialVersionUID = -5006209596735204567L;
+
+        /** The wrapped Subscriber instance. */
+        final Subscriber<? super T> actual;
+        
+        /** Holds the current requested amount. */
+        final AtomicLong requested;
+
+        /** Holds the back-reference to the replay state object. */
+        final ReplayState<T> state;
+
+        /** 
+         * Indicates this Subscriber runs unbounded and the <b>source</b>-triggered
+         * buffer.drain() has emitted all available values.
+         * <p>
+         * This field has to be read and written from the source emitter's thread only.
+         */
+        boolean caughtUp;
+        
+        /** 
+         * Unbounded buffer.drain() uses this field to remember the absolute index of
+         * values replayed to this Subscriber.
+         */
+        int index;
+        
+        /** 
+         * Unbounded buffer.drain() uses this index within its current node to indicate
+         * how many items were replayed from that particular node so far.
+         */
+        int tailIndex;
+        
+        /** 
+         * Stores the current replay node of the buffer to be used by buffer.drain().
+         */
+        Object node;
+        
+        public ReplayProducer(Subscriber<? super T> actual, ReplayState<T> state) {
+            this.actual = actual;
+            this.requested = new AtomicLong();
+            this.state = state;
         }
-        return null;
-    }
-    /**
-     * Returns the current number of items (non-terminal events) available for replay.
-     * @return the number of items available
-     */
-    @Beta
-    public int size() {
-        return state.size();
-    }
-    /**
-     * @return true if the Subject holds at least one non-terminal event available for replay
-     */
-    @Beta
-    public boolean hasAnyValue() {
-        return !state.isEmpty();
-    }
-    @Beta
-    public boolean hasValue() {
-        return hasAnyValue();
-    }
-    /**
-     * Returns a snapshot of the currently buffered non-terminal events into 
-     * the provided {@code a} array or creates a new array if it has not enough capacity.
-     * @param a the array to fill in
-     * @return the array {@code a} if it had enough capacity or a new array containing the available values 
-     */
-    @Beta
-    public T[] getValues(T[] a) {
-        return state.toArray(a);
-    }
-    
-    /** An empty array to trigger getValues() to return a new array. */
-    private static final Object[] EMPTY_ARRAY = new Object[0];
-    
-    /**
-     * Returns a snapshot of the currently buffered non-terminal events.
-     * <p>The operation is threadsafe.
-     *
-     * @return a snapshot of the currently buffered non-terminal events.
-     * @since (If this graduates from being an Experimental class method, replace this parenthetical with the release number)
-     */
-    @SuppressWarnings("unchecked")
-    @Beta
-    public Object[] getValues() {
-        T[] r = getValues((T[])EMPTY_ARRAY);
-        if (r == EMPTY_ARRAY) {
-            return new Object[0]; // don't leak the default empty array.
+        
+        @Override
+        public void unsubscribe() {
+            state.remove(this);
         }
-        return r;
-    }
-    
-    @Beta
-    public T getValue() {
-        return state.latest();
+
+        @Override
+        public boolean isUnsubscribed() {
+            return actual.isUnsubscribed();
+        }
+
+        @Override
+        public void request(long n) {
+            if (n > 0L) {
+                BackpressureUtils.getAndAddRequest(requested, n);
+                state.buffer.drain(this);
+            } else if (n < 0L) {
+                throw new IllegalArgumentException("n >= required but it was " + n);
+            }
+        }
+        
     }
 }
diff --git a/src/test/java/rx/subjects/ReplaySubjectTest.java b/src/test/java/rx/subjects/ReplaySubjectTest.java
index cd04fc02cc..7d5b5b8785 100644
--- a/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -443,52 +443,6 @@ public void onCompleted() {
         verify(o, never()).onError(any(Throwable.class));
     }
     @Test
-    public void testNodeListSimpleAddRemove() {
-        ReplaySubject.NodeList<Integer> list = new ReplaySubject.NodeList<Integer>();
-        
-        assertEquals(0, list.size());
-        
-        // add and remove one
-        
-        list.addLast(1);
-
-        assertEquals(1, list.size());
-        
-        assertEquals((Integer)1, list.removeFirst());
-
-        assertEquals(0, list.size());
-
-        // add and remove one again
-        
-        list.addLast(1);
-
-        assertEquals(1, list.size());
-        
-        assertEquals((Integer)1, list.removeFirst());
-
-        // add and remove two items
-        
-        list.addLast(1);
-        list.addLast(2);
-
-        assertEquals(2, list.size());
-
-        assertEquals((Integer)1, list.removeFirst());
-        assertEquals((Integer)2, list.removeFirst());
-
-        assertEquals(0, list.size());
-        // clear two items
-        
-        list.addLast(1);
-        list.addLast(2);
-
-        assertEquals(2, list.size());
-        
-        list.clear();
-
-        assertEquals(0, list.size());
-    }
-    @Test
     public void testReplay1AfterTermination() {
         ReplaySubject<Integer> source = ReplaySubject.createWithSize(1);
         
@@ -555,7 +509,7 @@ public void testReplayTimestampedAfterTermination() {
         
         verify(o, never()).onNext(1);
         verify(o, never()).onNext(2);
-        verify(o).onNext(3);
+        verify(o, never()).onNext(3); // late subscribers no longer replay stale data
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
@@ -844,9 +798,12 @@ public void testSizeAndHasAnyValueTimeBounded() {
         
         for (int i = 0; i < 1000; i++) {
             rs.onNext(i);
-            ts.advanceTimeBy(2, TimeUnit.SECONDS);
+            ts.advanceTimeBy(500, TimeUnit.MILLISECONDS);
             assertEquals(1, rs.size());
             assertTrue(rs.hasAnyValue());
+            ts.advanceTimeBy(1500, TimeUnit.MILLISECONDS);
+            assertEquals(0, rs.size()); // stale data no longer peekable
+            assertFalse(rs.hasAnyValue());
         }
         
         rs.onCompleted();
@@ -1049,4 +1006,139 @@ public void testReplaySubjectBoundedError() {
         assertArrayEquals(new Integer[] { null }, async.getValues(new Integer[] { 0 }));
         assertArrayEquals(new Integer[] { null, 0 }, async.getValues(new Integer[] { 0, 0 }));
     }
+    
+    void backpressureLive(ReplaySubject<Integer> rs) {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        
+        rs.subscribe(ts);
+        
+        for (int i = 1; i <= 5; i++) {
+            rs.onNext(i);
+        }
+        
+        ts.assertNoValues();
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1, 2);
+        
+        ts.requestMore(6);
+
+        ts.assertValues(1, 2, 3, 4, 5);
+        
+        for (int i = 6; i <= 10; i++) {
+            rs.onNext(i);
+        }
+
+        ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8);
+        
+        rs.onCompleted();
+        
+        ts.assertNotCompleted();
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    void backpressureOffline(ReplaySubject<Integer> rs) {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        
+        for (int i = 1; i <= 10; i++) {
+            rs.onNext(i);
+        }
+        rs.onCompleted();
+
+        rs.subscribe(ts);
+
+        ts.assertNoValues();
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1, 2);
+        
+        ts.requestMore(6);
+        
+        ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8);
+        
+        ts.assertNotCompleted();
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    void backpressureOffline5(ReplaySubject<Integer> rs) {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        
+        for (int i = 1; i <= 10; i++) {
+            rs.onNext(i);
+        }
+        rs.onCompleted();
+
+        rs.subscribe(ts);
+
+        ts.assertNoValues();
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(6, 7);
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(6, 7, 8, 9);
+        
+        ts.assertNotCompleted();
+        
+        ts.requestMore(1);
+        
+        ts.assertValues(6, 7, 8, 9, 10);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void backpressureUnboundedLive() {
+        backpressureLive(ReplaySubject.<Integer>create());
+    }
+
+    @Test
+    public void backpressureSizeBoundLive() {
+        backpressureLive(ReplaySubject.<Integer>createWithSize(1));
+        backpressureLive(ReplaySubject.<Integer>createWithSize(5));
+        backpressureLive(ReplaySubject.<Integer>createWithSize(10));
+        backpressureLive(ReplaySubject.<Integer>createWithSize(100));
+    }
+
+    @Test
+    public void backpressureSizeAndTimeLive() {
+        backpressureLive(ReplaySubject.<Integer>createWithTimeAndSize(1, TimeUnit.DAYS, 1, Schedulers.immediate()));
+        backpressureLive(ReplaySubject.<Integer>createWithTimeAndSize(1, TimeUnit.DAYS, 5, Schedulers.immediate()));
+        backpressureLive(ReplaySubject.<Integer>createWithTimeAndSize(1, TimeUnit.DAYS, 10, Schedulers.immediate()));
+        backpressureLive(ReplaySubject.<Integer>createWithTimeAndSize(1, TimeUnit.DAYS, 100, Schedulers.immediate()));
+    }
+
+    @Test
+    public void backpressureUnboundedOffline() {
+        backpressureOffline(ReplaySubject.<Integer>create());
+    }
+
+    @Test
+    public void backpressureSizeBoundOffline() {
+        backpressureOffline5(ReplaySubject.<Integer>createWithSize(5));
+        backpressureOffline(ReplaySubject.<Integer>createWithSize(10));
+        backpressureOffline(ReplaySubject.<Integer>createWithSize(100));
+    }
+
+    @Test
+    public void backpressureSizeAndTimeOffline() {
+        backpressureOffline5(ReplaySubject.<Integer>createWithTimeAndSize(1, TimeUnit.DAYS, 5, Schedulers.immediate()));
+        backpressureOffline(ReplaySubject.<Integer>createWithTimeAndSize(1, TimeUnit.DAYS, 10, Schedulers.immediate()));
+        backpressureOffline(ReplaySubject.<Integer>createWithTimeAndSize(1, TimeUnit.DAYS, 100, Schedulers.immediate()));
+    }
+
 }

From aa183b0771858c02be6a11bff8817d1857cbc462 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 16 Jun 2016 01:43:37 +0200
Subject: [PATCH 050/263] 1.x: Release 1.1.6 CHANGES.md (#4008)

---
 CHANGES.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 61ed87a90c..efc3a614d5 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,34 @@
 # RxJava Releases #
 
+### Version 1.1.6 - June 15, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.6%7C))
+
+#### API enhancements
+
+  - [Pull 3934](https://github.com/ReactiveX/RxJava/pull/3934): `TestSubscriber` extra info on assertion failures
+  - [Pull 3948](https://github.com/ReactiveX/RxJava/pull/3948): add `Completable.andThen(Completable)`
+  - [Pull 3942](https://github.com/ReactiveX/RxJava/pull/3942): add `Completable.subscribe` to be safe, add `unsafeSubscribe` option + `RxJavaPlugins` hook support 
+  - [Pull 3936](https://github.com/ReactiveX/RxJava/pull/3936): promote `UnicastSubject` to be a standard+experimental `Subject`
+  - [Pull 3971](https://github.com/ReactiveX/RxJava/pull/3971): add `Observable.rebatchRequests` operator to change and stabilize request amounts of the downstream.
+  - [Pull 3986](https://github.com/ReactiveX/RxJava/pull/3986): add `Schedulers.reset()` for better testing
+  - [Pull 3918](https://github.com/ReactiveX/RxJava/pull/3918): `ReplaySubject` now supports backpressure 
+
+#### API deprecations
+
+  - [Pull 3948](https://github.com/ReactiveX/RxJava/pull/3948) deprecate `Completable.endWith()` in favor of `andThen()`
+
+#### Performance enhancements
+
+  - [Pull 3470](https://github.com/ReactiveX/RxJava/pull/3470): `replay` request coordination reduce overhead
+
+#### Bugfixes
+
+  - [Pull 3924](https://github.com/ReactiveX/RxJava/pull/3924): fix `RxRingBuffer`-pool depending on the `computation` scheduler 
+  - [Pull 3922](https://github.com/ReactiveX/RxJava/pull/3922): fix `using()` resource cleanup when factory throws or being non-eager 
+  - [Pull 3941](https://github.com/ReactiveX/RxJava/pull/3941): fix `Single.flatMap` not composing subscription through 
+  - [Pull 3958](https://github.com/ReactiveX/RxJava/pull/3958): fix `just()` construction to call the `onCreate` execution hook 
+  - [Pull 3977](https://github.com/ReactiveX/RxJava/pull/3977): Use the correct `Throwable` to set the cause for `CompositeException`
+  - [Pull 4005](https://github.com/ReactiveX/RxJava/pull/4005): Fix Spsc queues reporting not empty but then poll() returns null.
+
 ### Version 1.1.5 - May 5, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.5%7C))
 
 #### Bugfixes

From 60c8ff98d0702278c2dbb5b07da932f3105a3738 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 16 Jun 2016 23:57:17 +0200
Subject: [PATCH 051/263] 1.x: add multi-other withLatestFrom operators (#3966)

---
 src/main/java/rx/Observable.java              | 327 +++++++++++++++-
 .../operators/OperatorWithLatestFromMany.java | 214 ++++++++++
 .../operators/OperatorWithLatestFromTest.java | 365 +++++++++++++++++-
 3 files changed, 903 insertions(+), 3 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index b48299cd65..1d213bf6d0 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -10129,7 +10129,332 @@ public final Observable<T> unsubscribeOn(Scheduler scheduler) {
     public final <U, R> Observable<R> withLatestFrom(Observable<? extends U> other, Func2<? super T, ? super U, ? extends R> resultSelector) {
         return lift(new OperatorWithLatestFrom<T, U, R>(other, resultSelector));
     }
-    
+
+    /**
+     * Combines the value emission from this Observable with the latest emissions from the
+     * other Observables via a function to produce the output item.
+     * 
+     * <p>Note that this operator doesn't emit anything until all other sources have produced at
+     * least one value. The resulting emission only happens when this Observable emits (and
+     * not when any of the other sources emit, unlike combineLatest). 
+     * If a source doesn't produce any value and just completes, the sequence is completed immediately.
+     * 
+     * <dl>
+     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T1> the first other source's value type
+     * @param <T2> the second other source's value type
+     * @param <R> the result value type
+     * @param others the array of other sources
+     * @param combiner the function called with an array of values from each participating observable
+     * @return the new Observable instance
+     * @Experimental The behavior of this can change at any time.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final <T1, T2, R> Observable<R> withLatestFrom(Observable<T1> o1, Observable<T2> o2, Func3<? super T, ? super T1, ? super T2, R> combiner) {
+        return create(new OperatorWithLatestFromMany<T, R>(this, new Observable<?>[] { o1, o2 }, null, Functions.fromFunc(combiner)));
+    }
+
+    /**
+     * Combines the value emission from this Observable with the latest emissions from the
+     * other Observables via a function to produce the output item.
+     * 
+     * <p>Note that this operator doesn't emit anything until all other sources have produced at
+     * least one value. The resulting emission only happens when this Observable emits (and
+     * not when any of the other sources emit, unlike combineLatest). 
+     * If a source doesn't produce any value and just completes, the sequence is completed immediately.
+     * 
+     * <dl>
+     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T1> the first other source's value type
+     * @param <T2> the second other source's value type
+     * @param <T3> the third other source's value type
+     * @param <R> the result value type
+     * @param others the array of other sources
+     * @param combiner the function called with an array of values from each participating observable
+     * @return the new Observable instance
+     * @Experimental The behavior of this can change at any time.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final <T1, T2, T3, R> Observable<R> withLatestFrom(
+            Observable<T1> o1, Observable<T2> o2, 
+            Observable<T3> o3, 
+            Func4<? super T, ? super T1, ? super T2, ? super T3, R> combiner) {
+        return create(new OperatorWithLatestFromMany<T, R>(this, 
+                new Observable<?>[] { o1, o2, o3 }, null, Functions.fromFunc(combiner)));
+    }
+
+    /**
+     * Combines the value emission from this Observable with the latest emissions from the
+     * other Observables via a function to produce the output item.
+     * 
+     * <p>Note that this operator doesn't emit anything until all other sources have produced at
+     * least one value. The resulting emission only happens when this Observable emits (and
+     * not when any of the other sources emit, unlike combineLatest). 
+     * If a source doesn't produce any value and just completes, the sequence is completed immediately.
+     * 
+     * <dl>
+     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T1> the first other source's value type
+     * @param <T2> the second other source's value type
+     * @param <T3> the third other source's value type
+     * @param <T4> the fourth other source's value type
+     * @param <R> the result value type
+     * @param others the array of other sources
+     * @param combiner the function called with an array of values from each participating observable
+     * @return the new Observable instance
+     * @Experimental The behavior of this can change at any time.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final <T1, T2, T3, T4, R> Observable<R> withLatestFrom(
+            Observable<T1> o1, Observable<T2> o2, 
+            Observable<T3> o3, Observable<T4> o4, 
+            Func5<? super T, ? super T1, ? super T2, ? super T3, ? super T4, R> combiner) {
+        return create(new OperatorWithLatestFromMany<T, R>(this, 
+                new Observable<?>[] { o1, o2, o3, o4 }, null, Functions.fromFunc(combiner)));
+    }
+    /**
+     * Combines the value emission from this Observable with the latest emissions from the
+     * other Observables via a function to produce the output item.
+     * 
+     * <p>Note that this operator doesn't emit anything until all other sources have produced at
+     * least one value. The resulting emission only happens when this Observable emits (and
+     * not when any of the other sources emit, unlike combineLatest). 
+     * If a source doesn't produce any value and just completes, the sequence is completed immediately.
+     * 
+     * <dl>
+     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T1> the first other source's value type
+     * @param <T2> the second other source's value type
+     * @param <T3> the third other source's value type
+     * @param <T4> the fourth other source's value type
+     * @param <T5> the fifth other source's value type
+     * @param <R> the result value type
+     * @param others the array of other sources
+     * @param combiner the function called with an array of values from each participating observable
+     * @return the new Observable instance
+     * @Experimental The behavior of this can change at any time.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final <T1, T2, T3, T4, T5, R> Observable<R> withLatestFrom(
+            Observable<T1> o1, Observable<T2> o2, 
+            Observable<T1> o3, Observable<T2> o4, 
+            Observable<T1> o5, 
+            Func6<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, R> combiner) {
+        return create(new OperatorWithLatestFromMany<T, R>(this, 
+                new Observable<?>[] { o1, o2, o3, o4, o5 }, null, Functions.fromFunc(combiner)));
+    }
+
+    /**
+     * Combines the value emission from this Observable with the latest emissions from the
+     * other Observables via a function to produce the output item.
+     * 
+     * <p>Note that this operator doesn't emit anything until all other sources have produced at
+     * least one value. The resulting emission only happens when this Observable emits (and
+     * not when any of the other sources emit, unlike combineLatest). 
+     * If a source doesn't produce any value and just completes, the sequence is completed immediately.
+     * 
+     * <dl>
+     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T1> the first other source's value type
+     * @param <T2> the second other source's value type
+     * @param <T3> the third other source's value type
+     * @param <T4> the fourth other source's value type
+     * @param <T5> the fifth other source's value type
+     * @param <T6> the sixth other source's value type
+     * @param <R> the result value type
+     * @param others the array of other sources
+     * @param combiner the function called with an array of values from each participating observable
+     * @return the new Observable instance
+     * @Experimental The behavior of this can change at any time.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final <T1, T2, T3, T4, T5, T6, R> Observable<R> withLatestFrom(
+            Observable<T1> o1, Observable<T2> o2, 
+            Observable<T1> o3, Observable<T2> o4, 
+            Observable<T1> o5, Observable<T2> o6, 
+            Func7<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, R> combiner) {
+        return create(new OperatorWithLatestFromMany<T, R>(this, 
+                new Observable<?>[] { o1, o2, o3, o4, o5, o6 }, null, Functions.fromFunc(combiner)));
+    }
+
+    /**
+     * Combines the value emission from this Observable with the latest emissions from the
+     * other Observables via a function to produce the output item.
+     * 
+     * <p>Note that this operator doesn't emit anything until all other sources have produced at
+     * least one value. The resulting emission only happens when this Observable emits (and
+     * not when any of the other sources emit, unlike combineLatest). 
+     * If a source doesn't produce any value and just completes, the sequence is completed immediately.
+     * 
+     * <dl>
+     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T1> the first other source's value type
+     * @param <T2> the second other source's value type
+     * @param <T3> the third other source's value type
+     * @param <T4> the fourth other source's value type
+     * @param <T5> the fifth other source's value type
+     * @param <T6> the sixth other source's value type
+     * @param <T7> the seventh other source's value type
+     * @param <R> the result value type
+     * @param others the array of other sources
+     * @param combiner the function called with an array of values from each participating observable
+     * @return the new Observable instance
+     * @Experimental The behavior of this can change at any time.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> withLatestFrom(
+            Observable<T1> o1, Observable<T2> o2, 
+            Observable<T1> o3, Observable<T2> o4, 
+            Observable<T1> o5, Observable<T2> o6, 
+            Observable<T1> o7,
+            Func8<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, R> combiner) {
+        return create(new OperatorWithLatestFromMany<T, R>(this, 
+                new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7 }, null, Functions.fromFunc(combiner)));
+    }
+
+    /**
+     * Combines the value emission from this Observable with the latest emissions from the
+     * other Observables via a function to produce the output item.
+     * 
+     * <p>Note that this operator doesn't emit anything until all other sources have produced at
+     * least one value. The resulting emission only happens when this Observable emits (and
+     * not when any of the other sources emit, unlike combineLatest). 
+     * If a source doesn't produce any value and just completes, the sequence is completed immediately.
+     * 
+     * <dl>
+     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T1> the first other source's value type
+     * @param <T2> the second other source's value type
+     * @param <T3> the third other source's value type
+     * @param <T4> the fourth other source's value type
+     * @param <T5> the fifth other source's value type
+     * @param <T6> the sixth other source's value type
+     * @param <T7> the seventh other source's value type
+     * @param <T8> the eigth other source's value type
+     * @param <R> the result value type
+     * @param others the array of other sources
+     * @param combiner the function called with an array of values from each participating observable
+     * @return the new Observable instance
+     * @Experimental The behavior of this can change at any time.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> withLatestFrom(
+            Observable<T1> o1, Observable<T2> o2, 
+            Observable<T1> o3, Observable<T2> o4, 
+            Observable<T1> o5, Observable<T2> o6, 
+            Observable<T1> o7, Observable<T2> o8, 
+            Func9<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, R> combiner) {
+        return create(new OperatorWithLatestFromMany<T, R>(this, 
+                new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7, o8 }, null, Functions.fromFunc(combiner)));
+    }
+
+    /**
+     * Combines the value emission from this Observable with the latest emissions from the
+     * other Observables via a function to produce the output item.
+     * 
+     * <p>Note that this operator doesn't emit anything until all other sources have produced at
+     * least one value. The resulting emission only happens when this Observable emits (and
+     * not when any of the other sources emit, unlike combineLatest). 
+     * If a source doesn't produce any value and just completes, the sequence is completed immediately.
+     * 
+     * <dl>
+     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * 
+     * @param <R> the result value type
+     * @param others the array of other sources
+     * @param combiner the function called with an array of values from each participating observable
+     * @return the new Observable instance
+     * @Experimental The behavior of this can change at any time.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final <R> Observable<R> withLatestFrom(Observable<?>[] others, FuncN<R> combiner) {
+        return create(new OperatorWithLatestFromMany<T, R>(this, others, null, combiner));
+    }
+
+    /**
+     * Combines the value emission from this Observable with the latest emissions from the
+     * other Observables via a function to produce the output item.
+     * 
+     * <p>Note that this operator doesn't emit anything until all other sources have produced at
+     * least one value. The resulting emission only happens when this Observable emits (and
+     * not when any of the other sources emit, unlike combineLatest). 
+     * If a source doesn't produce any value and just completes, the sequence is completed immediately.
+     * 
+     * <dl>
+     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * 
+     * @param <R> the result value type
+     * @param others the iterable of other sources
+     * @param combiner the function called with an array of values from each participating observable
+     * @return the new Observable instance
+     * @Experimental The behavior of this can change at any time.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final <R> Observable<R> withLatestFrom(Iterable<Observable<?>> others, FuncN<R> combiner) {
+        return create(new OperatorWithLatestFromMany<T, R>(this, null, others, combiner));
+    }
+
     /**
      * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
      * Observable emits connected, non-overlapping windows. It emits the current window and opens a new one
diff --git a/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java b/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java
new file mode 100644
index 0000000000..91c390e63d
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java
@@ -0,0 +1,214 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import java.util.Arrays;
+import java.util.concurrent.atomic.*;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.exceptions.Exceptions;
+import rx.functions.FuncN;
+import rx.internal.util.RxJavaPluginUtils;
+import rx.observers.SerializedSubscriber;
+
+public final class OperatorWithLatestFromMany<T, R> implements OnSubscribe<R> {
+    final Observable<T> main;
+    
+    final Observable<?>[] others;
+    
+    final Iterable<Observable<?>> othersIterable;
+    
+    final FuncN<R> combiner;
+    
+    public OperatorWithLatestFromMany(Observable<T> main, Observable<?>[] others, Iterable<Observable<?>> othersIterable, FuncN<R> combiner) {
+        this.main = main;
+        this.others = others;
+        this.othersIterable = othersIterable;
+        this.combiner = combiner;
+    }
+
+    @Override
+    public void call(Subscriber<? super R> t) {
+        SerializedSubscriber<R> serial = new SerializedSubscriber<R>(t);
+        
+        
+        Observable<?>[] sources;
+        int n = 0;
+        
+        if (others != null) {
+            sources = others;
+            n = sources.length;
+        } else {
+            sources = new Observable[8];
+            for (Observable<?> o : othersIterable) {
+                if (n == sources.length) {
+                    sources = Arrays.copyOf(sources, n + (n >> 2));
+                }
+                sources[n++] = o;
+            }
+        }
+            
+        WithLatestMainSubscriber<T, R> parent = new WithLatestMainSubscriber<T, R>(t, combiner, n);
+    
+        serial.add(parent);
+
+            
+        for (int i = 0; i < n; i++) {
+            Observable<?> o = sources[i];
+            if (serial.isUnsubscribed()) {
+                return;
+            }
+            
+            WithLatestOtherSubscriber inner = new WithLatestOtherSubscriber(parent, i + 1);
+            parent.add(inner);
+            
+            o.unsafeSubscribe(inner);
+        }
+        
+        main.unsafeSubscribe(parent);
+    }
+    
+    static final class WithLatestMainSubscriber<T, R> extends Subscriber<T> {
+        final Subscriber<? super R> actual;
+        
+        final FuncN<R> combiner;
+        
+        final AtomicReferenceArray<Object> current;
+        
+        static final Object EMPTY = new Object();
+        
+        final AtomicInteger ready;
+        
+        boolean done;
+        
+        public WithLatestMainSubscriber(Subscriber<? super R> actual, FuncN<R> combiner, int n) {
+            this.actual = actual;
+            this.combiner = combiner;
+            
+            AtomicReferenceArray<Object> array = new AtomicReferenceArray<Object>(n + 1);
+            for (int i = 0; i <= n; i++) {
+                array.lazySet(i, EMPTY);
+            }
+            this.current = array;
+            
+            this.ready = new AtomicInteger(n);
+            this.request(0);
+        }
+        
+        @Override
+        public void onNext(T t) {
+            if (done) {
+                return;
+            }
+            if (ready.get() == 0) {
+                
+                AtomicReferenceArray<Object> array = current;
+                int n = array.length();
+                array.lazySet(0, t);
+                
+                Object[] copy = new Object[array.length()];
+                for (int i = 0; i < n; i++) {
+                    copy[i] = array.get(i);
+                }
+                
+                R result;
+                
+                try {
+                    result = combiner.call(copy);
+                } catch (Throwable ex) {
+                    Exceptions.throwIfFatal(ex);
+                    onError(ex);
+                    return;
+                }
+                
+                actual.onNext(result);
+            } else {
+                request(1);
+            }
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            if (done) {
+                RxJavaPluginUtils.handleException(e);
+                return;
+            }
+            done = true;
+            unsubscribe();
+            actual.onError(e);
+        }
+        
+        @Override
+        public void onCompleted() {
+            if (done) {
+                return;
+            }
+            done = true;
+            unsubscribe();
+            actual.onCompleted();
+        }
+        
+        @Override
+        public void setProducer(Producer p) {
+            super.setProducer(p);
+            actual.setProducer(p);
+        }
+        
+        void innerNext(int index, Object o) {
+            Object last = current.getAndSet(index, o);
+            if (last == EMPTY) {
+                ready.decrementAndGet();
+            }
+        }
+        
+        void innerError(int index, Throwable e) {
+            onError(e);
+        }
+        
+        void innerComplete(int index) {
+            if (current.get(index) == EMPTY) {
+                onCompleted();
+            }
+        }
+    }
+    
+    static final class WithLatestOtherSubscriber extends Subscriber<Object> {
+        final WithLatestMainSubscriber<?, ?> parent;
+        
+        final int index;
+
+        public WithLatestOtherSubscriber(WithLatestMainSubscriber<?, ?> parent, int index) {
+            this.parent = parent;
+            this.index = index;
+        }
+        
+        @Override
+        public void onNext(Object t) {
+            parent.innerNext(index, t);
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            parent.innerError(index, e);
+        }
+        
+        @Override
+        public void onCompleted() {
+            parent.innerComplete(index);
+        }
+    }
+}
diff --git a/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java b/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java
index a172158115..a0a6a9d20c 100644
--- a/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java
+++ b/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java
@@ -21,13 +21,13 @@
 
 import java.util.*;
 
-import org.junit.Test;
+import org.junit.*;
 import org.mockito.InOrder;
 
 import rx.Observable;
 import rx.Observer;
 import rx.exceptions.TestException;
-import rx.functions.Func2;
+import rx.functions.*;
 import rx.observers.TestSubscriber;
 import rx.subjects.PublishSubject;
 
@@ -295,4 +295,365 @@ public void onStart() {
 
         ts.assertNoErrors();
     }
+
+    static final FuncN<String> toArray = new FuncN<String>() {
+        @Override
+        public String call(Object... args) {
+            return Arrays.toString(args);
+        }
+    };
+
+    @Test
+    public void manySources() {
+        PublishSubject<String> ps1 = PublishSubject.create();
+        PublishSubject<String> ps2 = PublishSubject.create();
+        PublishSubject<String> ps3 = PublishSubject.create();
+        PublishSubject<String> main = PublishSubject.create();
+        
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+        
+        main.withLatestFrom(new Observable[] { ps1, ps2, ps3 }, toArray)
+        .subscribe(ts);
+        
+        main.onNext("1");
+        ts.assertNoValues();
+        ps1.onNext("a");
+        ts.assertNoValues();
+        ps2.onNext("A");
+        ts.assertNoValues();
+        ps3.onNext("=");
+        ts.assertNoValues();
+        
+        main.onNext("2");
+        ts.assertValues("[2, a, A, =]");
+        
+        ps2.onNext("B");
+        
+        ts.assertValues("[2, a, A, =]");
+        
+        ps3.onCompleted();
+        ts.assertValues("[2, a, A, =]");
+        
+        ps1.onNext("b");
+        
+        main.onNext("3");
+        
+        ts.assertValues("[2, a, A, =]", "[3, b, B, =]");
+        
+        main.onCompleted();
+        ts.assertValues("[2, a, A, =]", "[3, b, B, =]");
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+        Assert.assertFalse("ps1 has subscribers?", ps1.hasObservers());
+        Assert.assertFalse("ps2 has subscribers?", ps2.hasObservers());
+        Assert.assertFalse("ps3 has subscribers?", ps3.hasObservers());
+    }
+    
+    @Test
+    public void manySourcesIterable() {
+        PublishSubject<String> ps1 = PublishSubject.create();
+        PublishSubject<String> ps2 = PublishSubject.create();
+        PublishSubject<String> ps3 = PublishSubject.create();
+        PublishSubject<String> main = PublishSubject.create();
+        
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+        
+        main.withLatestFrom(Arrays.<Observable<?>>asList(ps1, ps2, ps3), toArray)
+        .subscribe(ts);
+        
+        main.onNext("1");
+        ts.assertNoValues();
+        ps1.onNext("a");
+        ts.assertNoValues();
+        ps2.onNext("A");
+        ts.assertNoValues();
+        ps3.onNext("=");
+        ts.assertNoValues();
+        
+        main.onNext("2");
+        ts.assertValues("[2, a, A, =]");
+        
+        ps2.onNext("B");
+        
+        ts.assertValues("[2, a, A, =]");
+        
+        ps3.onCompleted();
+        ts.assertValues("[2, a, A, =]");
+        
+        ps1.onNext("b");
+        
+        main.onNext("3");
+        
+        ts.assertValues("[2, a, A, =]", "[3, b, B, =]");
+        
+        main.onCompleted();
+        ts.assertValues("[2, a, A, =]", "[3, b, B, =]");
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+        Assert.assertFalse("ps1 has subscribers?", ps1.hasObservers());
+        Assert.assertFalse("ps2 has subscribers?", ps2.hasObservers());
+        Assert.assertFalse("ps3 has subscribers?", ps3.hasObservers());
+    }
+    
+    @Test
+    public void manySourcesIterableSweep() {
+        for (String val : new String[] { "1", null }) {
+            int n = 35;
+            for (int i = 0; i < n; i++) {
+                List<Observable<?>> sources = new ArrayList<Observable<?>>();
+                List<String> expected = new ArrayList<String>();
+                expected.add(val);
+                
+                for (int j = 0; j < i; j++) {
+                    sources.add(Observable.just(val));
+                    expected.add(String.valueOf(val));
+                }
+                
+                TestSubscriber<String> ts = new TestSubscriber<String>();
+                
+                PublishSubject<String> main = PublishSubject.create();
+                
+                main.withLatestFrom(sources, toArray).subscribe(ts);
+                
+                ts.assertNoValues();
+                
+                main.onNext(val);
+                main.onCompleted();
+                
+                ts.assertValue(expected.toString());
+                ts.assertNoErrors();
+                ts.assertCompleted();
+            }
+        }
+    }
+    
+    @Test
+    public void backpressureNoSignal() {
+        PublishSubject<String> ps1 = PublishSubject.create();
+        PublishSubject<String> ps2 = PublishSubject.create();
+        
+        TestSubscriber<String> ts = new TestSubscriber<String>(0);
+        
+        Observable.range(1, 10).withLatestFrom(new Observable<?>[] { ps1, ps2 }, toArray)
+        .subscribe(ts);
+        
+        ts.assertNoValues();
+        
+        ts.requestMore(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+        Assert.assertFalse("ps1 has subscribers?", ps1.hasObservers());
+        Assert.assertFalse("ps2 has subscribers?", ps2.hasObservers());
+    }
+    
+    @Test
+    public void backpressureWithSignal() {
+        PublishSubject<String> ps1 = PublishSubject.create();
+        PublishSubject<String> ps2 = PublishSubject.create();
+        
+        TestSubscriber<String> ts = new TestSubscriber<String>(0);
+        
+        Observable.range(1, 3).withLatestFrom(new Observable<?>[] { ps1, ps2 }, toArray)
+        .subscribe(ts);
+        
+        ts.assertNoValues();
+        
+        ps1.onNext("1");
+        ps2.onNext("1");
+        
+        ts.requestMore(1);
+        
+        ts.assertValue("[1, 1, 1]");
+        
+        ts.requestMore(1);
+
+        ts.assertValues("[1, 1, 1]", "[2, 1, 1]");
+
+        ts.requestMore(1);
+        
+        ts.assertValues("[1, 1, 1]", "[2, 1, 1]", "[3, 1, 1]");
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+        Assert.assertFalse("ps1 has subscribers?", ps1.hasObservers());
+        Assert.assertFalse("ps2 has subscribers?", ps2.hasObservers());
+    }
+    
+    @Test
+    public void withEmpty() {
+        TestSubscriber<String> ts = new TestSubscriber<String>(0);
+        
+        Observable.range(1, 3).withLatestFrom(
+                new Observable<?>[] { Observable.just(1), Observable.empty() }, toArray)
+        .subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void withError() {
+        TestSubscriber<String> ts = new TestSubscriber<String>(0);
+        
+        Observable.range(1, 3).withLatestFrom(
+                new Observable<?>[] { Observable.just(1), Observable.error(new TestException()) }, toArray)
+        .subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void withMainError() {
+        TestSubscriber<String> ts = new TestSubscriber<String>(0);
+        
+        Observable.error(new TestException()).withLatestFrom(
+                new Observable<?>[] { Observable.just(1), Observable.just(1) }, toArray)
+        .subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void with2Others() {
+        Observable<Integer> just = Observable.just(1);
+        
+        TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
+        
+        just.withLatestFrom(just, just, new Func3<Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer a, Integer b, Integer c) {
+                return Arrays.asList(a, b, c);
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue(Arrays.asList(1, 1, 1));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void with3Others() {
+        Observable<Integer> just = Observable.just(1);
+        
+        TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
+        
+        just.withLatestFrom(just, just, just, new Func4<Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer a, Integer b, Integer c, Integer d) {
+                return Arrays.asList(a, b, c, d);
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue(Arrays.asList(1, 1, 1, 1));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void with4Others() {
+        Observable<Integer> just = Observable.just(1);
+        
+        TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
+        
+        just.withLatestFrom(just, just, just, just, new Func5<Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e) {
+                return Arrays.asList(a, b, c, d, e);
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue(Arrays.asList(1, 1, 1, 1, 1));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void with5Others() {
+        Observable<Integer> just = Observable.just(1);
+        
+        TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
+        
+        just.withLatestFrom(just, just, just, just, just, new Func6<Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f) {
+                return Arrays.asList(a, b, c, d, e, f);
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue(Arrays.asList(1, 1, 1, 1, 1, 1));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void with6Others() {
+        Observable<Integer> just = Observable.just(1);
+        
+        TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
+        
+        just.withLatestFrom(just, just, just, just, just, just, new Func7<Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f, Integer g) {
+                return Arrays.asList(a, b, c, d, e, f, g);
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue(Arrays.asList(1, 1, 1, 1, 1, 1, 1));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void with7Others() {
+        Observable<Integer> just = Observable.just(1);
+        
+        TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
+        
+        just.withLatestFrom(just, just, just, just, just, just, just, new Func8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f, Integer g, Integer i) {
+                return Arrays.asList(a, b, c, d, e, f, g, i);
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue(Arrays.asList(1, 1, 1, 1, 1, 1, 1, 1));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void with8Others() {
+        Observable<Integer> just = Observable.just(1);
+        
+        TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
+        
+        just.withLatestFrom(just, just, just, just, just, just, just, just, new Func9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f, Integer g, Integer i, Integer j) {
+                return Arrays.asList(a, b, c, d, e, f, g, i, j);
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue(Arrays.asList(1, 1, 1, 1, 1, 1, 1, 1, 1));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
 }

From 607f68c2eb11e4978f0d0684f9deedd25e958c15 Mon Sep 17 00:00:00 2001
From: Klemen Kresnik <klemen@kresnik.me>
Date: Fri, 17 Jun 2016 10:37:28 +0200
Subject: [PATCH 052/263] Add vararg of Subscriptions to composite
 subscription. (#3720)

---
 .../subscriptions/CompositeSubscription.java  |  42 +++++-
 .../CompositeSubscriptionTest.java            | 139 ++++++++++++++++--
 2 files changed, 165 insertions(+), 16 deletions(-)

diff --git a/src/main/java/rx/subscriptions/CompositeSubscription.java b/src/main/java/rx/subscriptions/CompositeSubscription.java
index f4941875f5..876a04a56b 100644
--- a/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -15,6 +15,9 @@
  */
 package rx.subscriptions;
 
+import rx.Subscription;
+import rx.exceptions.Exceptions;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -22,9 +25,6 @@
 import java.util.List;
 import java.util.Set;
 
-import rx.Subscription;
-import rx.exceptions.*;
-
 /**
  * Subscription that represents a group of Subscriptions that are unsubscribed together.
  * <p>
@@ -54,7 +54,7 @@ public boolean isUnsubscribed() {
      * well.
      *
      * @param s
-     *          the {@link Subscription} to add
+     *         the {@link Subscription} to add
      */
     public void add(final Subscription s) {
         if (s.isUnsubscribed()) {
@@ -75,12 +75,44 @@ public void add(final Subscription s) {
         s.unsubscribe();
     }
 
+    /**
+     * Adds collection of {@link Subscription} to this {@code CompositeSubscription} if the
+     * {@code CompositeSubscription} is not yet unsubscribed. If the {@code CompositeSubscription} <em>is</em>
+     * unsubscribed, {@code addAll} will indicate this by explicitly unsubscribing all {@code Subscription} in collection as
+     * well.
+     *
+     * @param subscriptions
+     *         the collection of {@link Subscription} to add
+     */
+    public void addAll(final Subscription... subscriptions) {
+        if (!unsubscribed) {
+            synchronized (this) {
+                if (!unsubscribed) {
+                    if (this.subscriptions == null) {
+                        this.subscriptions = new HashSet<Subscription>(subscriptions.length);
+                    }
+
+                    for (Subscription s : subscriptions) {
+                        if (!s.isUnsubscribed()) {
+                            this.subscriptions.add(s);
+                        }
+                    }
+                    return;
+                }
+            }
+        }
+
+        for (Subscription s : subscriptions) {
+            s.unsubscribe();
+        }
+    }
+
     /**
      * Removes a {@link Subscription} from this {@code CompositeSubscription}, and unsubscribes the
      * {@link Subscription}.
      *
      * @param s
-     *          the {@link Subscription} to remove
+     *         the {@link Subscription} to remove
      */
     public void remove(final Subscription s) {
         if (!unsubscribed) {
diff --git a/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java b/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
index dacb8e11f0..ec9190e8fa 100644
--- a/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
+++ b/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
@@ -15,20 +15,19 @@
  */
 package rx.subscriptions;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import org.junit.Test;
+import rx.Subscription;
+import rx.exceptions.CompositeException;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import org.junit.Test;
-
-import rx.Subscription;
-import rx.exceptions.CompositeException;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 public class CompositeSubscriptionTest {
 
@@ -324,17 +323,18 @@ public void run() {
         // we should have only unsubscribed once
         assertEquals(1, counter.get());
     }
+
     @Test
     public void testTryRemoveIfNotIn() {
         CompositeSubscription csub = new CompositeSubscription();
-        
+
         CompositeSubscription csub1 = new CompositeSubscription();
         CompositeSubscription csub2 = new CompositeSubscription();
-        
+
         csub.add(csub1);
         csub.remove(csub1);
         csub.add(csub2);
-        
+
         csub.remove(csub1); // try removing again
     }
 
@@ -344,4 +344,121 @@ public void testAddingNullSubscriptionIllegal() {
         csub.add(null);
     }
 
+    @Test
+    public void testAddAll() {
+        final AtomicInteger counter = new AtomicInteger();
+        CompositeSubscription s = new CompositeSubscription();
+        s.addAll(new Subscription() {
+            @Override
+            public void unsubscribe() {
+                counter.incrementAndGet();
+            }
+
+            @Override
+            public boolean isUnsubscribed() {
+                return false;
+            }
+        }, new Subscription() {
+            @Override
+            public void unsubscribe() {
+                counter.incrementAndGet();
+            }
+
+            @Override
+            public boolean isUnsubscribed() {
+                return false;
+            }
+        }, new Subscription() {
+            @Override
+            public void unsubscribe() {
+                counter.incrementAndGet();
+            }
+
+            @Override
+            public boolean isUnsubscribed() {
+                return false;
+            }
+        }, new Subscription() {
+            @Override
+            public void unsubscribe() {
+                counter.incrementAndGet();
+            }
+
+            @Override
+            public boolean isUnsubscribed() {
+                return false;
+            }
+        });
+
+        s.unsubscribe();
+
+        assertEquals(4, counter.get());
+    }
+
+    @Test(timeout = 1000)
+    public void testAddAllConcurrent() throws InterruptedException {
+        final AtomicInteger counter = new AtomicInteger();
+        final CompositeSubscription s = new CompositeSubscription();
+
+        final int count = 10;
+        final CountDownLatch start = new CountDownLatch(1);
+        final CountDownLatch end = new CountDownLatch(10);
+        final List<Thread> threads = new ArrayList<Thread>();
+        for (int i = 0; i < count; i++) {
+            final Thread t = new Thread() {
+                @Override
+                public void run() {
+                    try {
+                        start.await();
+                        s.addAll(new Subscription() {
+                            @Override
+                            public void unsubscribe() {
+                                counter.incrementAndGet();
+                            }
+
+                            @Override
+                            public boolean isUnsubscribed() {
+                                return false;
+                            }
+                        }, new Subscription() {
+                            @Override
+                            public void unsubscribe() {
+                                counter.incrementAndGet();
+                            }
+
+                            @Override
+                            public boolean isUnsubscribed() {
+                                return false;
+                            }
+                        }, new Subscription() {
+                            @Override
+                            public void unsubscribe() {
+                                counter.incrementAndGet();
+                            }
+
+                            @Override
+                            public boolean isUnsubscribed() {
+                                return false;
+                            }
+                        });
+                        end.countDown();
+                    } catch (final InterruptedException e) {
+                        fail(e.getMessage());
+                    }
+                }
+            };
+            t.start();
+            threads.add(t);
+        }
+
+        start.countDown();
+        end.await();
+        s.unsubscribe();
+        for (final Thread t : threads) {
+            t.join();
+        }
+
+        assertEquals(30, counter.get());
+    }
+
 }

From cc050881c8de055e559841b2fdbb863ce560393d Mon Sep 17 00:00:00 2001
From: David Andrews <dta@alumni.cmu.edu>
Date: Fri, 17 Jun 2016 05:02:28 -0400
Subject: [PATCH 053/263] Add specificity to documentation for AsyncSubject
 (#4014)

* Update AsyncSubject.java

* Minor change to wording

* Update AsyncSubject.java
---
 src/main/java/rx/subjects/AsyncSubject.java | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/subjects/AsyncSubject.java b/src/main/java/rx/subjects/AsyncSubject.java
index dac007f03f..26057b6821 100644
--- a/src/main/java/rx/subjects/AsyncSubject.java
+++ b/src/main/java/rx/subjects/AsyncSubject.java
@@ -26,8 +26,10 @@
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 
 /**
- * Subject that publishes only the last item observed to each {@link Observer} that has subscribed, when the
- * source {@code Observable} completes.
+ * Subject that publishes only the last item observed to each {@link Observer} once the source {@code Observable}
+ * has completed.  The item is cached and published to any {@code Observer}s which subscribe after the source
+ * has completed.  If the source emitted no items, {@code AsyncSubject} completes without emitting anything.
+ * If the source terminated in an error, current and future subscribers will receive only the error.
  * <p>
  * <img width="640" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/S.AsyncSubject.png" alt="">
  * <p>

From 64a3d7ed064f459d686118e304140209e5b5f6da Mon Sep 17 00:00:00 2001
From: Artem Zinnatullin <artem.zinnatullin@gmail.com>
Date: Fri, 17 Jun 2016 18:39:17 +0300
Subject: [PATCH 054/263] 1.x: Update Gradle to 2.14 (#4018)

---
 gradle/wrapper/gradle-wrapper.jar        | Bin 53639 -> 53319 bytes
 gradle/wrapper/gradle-wrapper.properties |   4 +-
 gradlew                                  |  46 ++++++++++++-----------
 gradlew.bat                              |   6 +--
 4 files changed, 30 insertions(+), 26 deletions(-)

diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 2c6137b87896c8f70315ae454e00a969ef5f6019..d3b83982b9b1bccad955349d702be9b884c6e049 100644
GIT binary patch
delta 5041
zcmZWtc|26>A0ER*F=XEx`@T(<?8;6NvhOsOvSbU9CUosfb&@5d5F)~$L}(a{y|SbT
zBWqbIS>tyc_t(8X_x$sH&vTyVyS&@yeNSvYd3zo?(&Q{T#W5I+iVCJ`*n0;lL<Jgs
zR#~>9J1RCzSt|jn0c5a$IB1Yl%uBv+x<w$fF0*d{F|x^hTTKfOghRkBidhKoMHE0l
zH8U0C5eN~d{Q##2x%!x}?$38AU@*0#FqjPB*TMpb)1$C<7wjyUb`=a1dAW#<a{6`!
zHMi`{r1b@HVoU<ea6zg<#|7SOq1c$fsZIm3D{EV}PFx-f(N}1D6?@;O%XB0~tm~D0
zHs+fiB4Vn3je13df2(P#88+VC+D_FVYlyoNG1pcQC5l>*na5u}C!Vp|!k>I)Gtb%5
zn9uChqX{1@BJkKugy)+AR#PP@{YsHGBb2#>L1-C$S7;HvxOLjp{ZG?RSiRIg5nh=!
z2)AuBY@Oj>n$SXIMO}@o9kKPk7Pi|v_4W;4+s|{;EXjcnMk6Hez3tW(nHh=6q@tEH
zvT-L2ob%8*>vlDA>nL6>+Y4Ua+?;SToH&|SbFEiq4eJ@~<xrPivvyA^+Qwh9=JAJ^
zY}RC7;Y%2bm{|!Gdc%=XT|+vbkG9IsK0X@pB@EQD_#`s6_sdpi8PxSKjWX6>m}gc*
zi4=HQKVs)EjHNvGuIyrg<`3Jf#fF&9i*uv*Z#L0zqTksRP4JzQsqE#)VqC(6%Zs@2
zC+7pl-i2V<^{W{_NR9;&m29m)zbDa}UM1*6rriC_pW^G4A_!=tsS|B{jkK<f!jpAc
zrK<0rvpj)Mmr`1rXIMvby3C7^!cYB1&E|h06MmX#@AHyy6N%<`xokY-o;2?f7%`Rc
zIwP%y6c!nmTV$>(lK%8X94m!w>U!qjNrR<Ao^n?#x&3F;#G{erMdr4;4W)dM1;?}q
zz7?hckxQi3^r|Npz2^mc%ZV3^+>_tO_)^<v)cSNSjTtYvUm?C#m|IjUw_A3Y39x7r
zS~9p}R*ASEgelP{@gr&zXt)qI%<GRzM+mgix-)Tkc~K6`C=w&{!zo$jhor~^>6OB$
z3iIpO<SP_M&X1eHCDYQaPfHdi`}i_dh=1HsSTwmthFR<iJeI8#oc1eCJ9J7^oIkoV
z=$xw_d~n@0k7zC+ZyzaL`>}e(v0W@9R0TeGn(v4g#>Caecyy@t>x1jNYhQOWmO4o3
z<Dps8cx(6D6-Jfw9}?YG?zZPW8x_kFs5xi;8S6q-mx&@?&<Jz06=U?!Saqw->3%vX
zuo*MRmtIqPe%@UZZcU`xRt6mUn1(}+@X6Z*2u{aK{ifU2%al)RJYwJL#p72<_|AxE
z{h`>0I(aiaF$~pCojusnS8<z;{EMKiCKp1lZ$iCw`I^3lTg3RB-c2(}n9R*HDM+?A
zGFVf4iPzB&^e5`H-aq?>mp_#ey{#7-a{~27OY8Rz?>%|lU%Ih+0iF}Xb(B{>NisKW
zcb*8#k2M*l9nk(+Qai(C%l244w)Rd0PJ_Mo5eb$9AGkxF%@TTR(Y&65Fm@w^)?;)>
zDM;hZ%E0tXt}uey4Z50#{Yum8(+(c<YRyVmR?GEWCAKgc*3CJ++wqkCN*Y_}7=O99
z{B$TCl`l4-{<J;Qm1#6volYp5#aWLy9EDPfDW|Zc3qy4R{RmE-C!daejdIsz6Hzf?
zl{8~u?}}3oVql(@a`|~YBy&_Ni1CA7m`_7O`pQYsLBD8my?MbJT#EnCDG&P=FNwc|
zP@e;bWzNc&N*K3<q>a{GCvz(LrRx~}!|Bj2Sgp)*`(PJy-MAz^cLWCGpoPJNz+H?L
z$Z2K3rde(}aSqe(N$K0#l=(<pRB_gKJIBaN_H>NkV>ESNyq1CDo_L$FCJT;bF)pp@
zRn;S_u$M;5;%aZ}*CT+TJD>W`{|MhJuKoPM;cQ-<(B_%tp75+wKXR74AJpyb_ATzg
z{b=`+CRLNP?v=NjH0vha6~!ajbFED8eKWGL7Q-5%Tb(<MZ3<W)KX(guHJKy^>%=?|
z^KJ9vvO{}!VP{t=MbuB=g;zS+)c<1D*}^6Cb?kg#GbRO|yzbcM!|W6{m53HtF=KLK
z_#)l4!i@fDapyHl+pycNF4O0vDLeFa&d>C-(t4|7BCmyooh(-)m^DoNyz6o0tind^
zH9gpx1h4xN2-~45n()WPDk+m9idV1Q@D2#OeD#vc<r`~6Z{N#TUHsKm0&UJ*--@|$
zp^xcm>1~@lvQn9+6D!)C0rq17>1(cSCVm*-8^7X9;@h@L_z`w}tjU7y&nxaJ=-^LX
zynizFfljm#UuxF<c}KJUTrPXd<5?nKN`iw%aoD6x;!Ku{^n#a;)(-WC+n9nIw|C4Z
zBv8CvbT*im^osbYYAxWybJ@W9S7<`9Ldm6f1C`S^hNr%Hw)n08sLb+qTNK5*<A!@Q
z+lF*Pf>tCOX&d7GCcPsnm=TgaxS(R5`X?%cBq?p(A99O{+`%QSGTzuiBFY}|)}p%1
z8LO~4^R+Qr(GKJIY@|)RzWPi&*VbDt$p)P2_0V^IT#e4>vJiNG=AWB}DV2_uMj<M|
z$L&*Vc(0G;<{lqw{1L}4s#dlyydSDJrQL{E%%v6@QcyU1D!D{*_&HbV%<V6g`L~gR
zXM3Z%x3kwMJ0$Tv5<MPtR5o+=Rf%hSuPd-dB)2CHXOeW=GkH^g??!*{G{@>Q5TmIJ
z6B>Oxgv2A9kjWiKk@=zKcuIfMHgOK26)oiO3NEHdrj$4FlH+vaefb@#5II%K9IJZv
zw$L_-8KfOPRcBUsLzKPKb0f1%cQp{%bbLPjMgGK&N`+tLsyK7gkW94A_`;`YelhHg
z{K>kFoP^I_8|1siljk?8qon9YgnHZvJ(@!S$x(S*i6Ti;6;YmgEvqb<mi_NWaw@FL
zUtapUSsn7&Ty%!fveU@>xeVhIi}Dvoo8)v`f0ZU>y!pHmf(%*Big~Ji-Rjd-g;S@I
z@}Dk#kM1QTTDiz_c0Q<0z<P!{Fvui0V25%syRK1%X)-z5ZDHeLV|*E{cBc9dlbzj%
zec2Wp=;@kzx;pWlEi;!@$KMYU8aWmXYs(hgzbIAQ<)0!F#o2Dyg(!=N&YSpN;(ZbA
z@qojZTB~a}$0hYU`Uo`&Z{20t(DbbC`}4XMukaF6zpcHW>`lU$#&z!;>t1fIO>AWH
z)9Ou%qjz#A>MBeEOgO9y%z784)NTR81O!F^1&b4?-tCRY)VfufJ=+Ss=;4o-8oQf5
zkk}ZVs!ZzSw5uL&!zB9Yck&ih1vh!+o^!X`PCJ2OidogvkybYPwNu5--BAB9%BNjk
zA;NL?D?|0HFA9cX_t>xq%5`%7hMgnuzknf@XP+Vs$~B&Q<V>YT+zz-G?w!bmA}us#
zGxtuKBZ;NC3xX-=-qR?}(Br7b1)GK&G6coM$kpa%(tD<{3^x5jCoMZXk^T)_qfqnK
zHLBmag~01zX9IyqK^`F)_K_WFwUX>BMQ<%|!^eq*F_)?O3S!>LYfHrhV;_}wI1O;n
ze&ee()1tJpWsW83DF($Vn)~BodJ`wN>)U_L6V~U$-kOk1Fs$uXW@D2}`bY<rHNUXq
zlNlJ1XhlQa^Snm=S|e|svyL*Og4A#yGx*fXm~T9Ebe9?pT@b2~x_$q`^9`5-k33_+
z_oHUVpXA^}@0#7px}FU`NyOU!rASv0_q;KIQ9e8SlJ-<I>Q~FMoZt!<W5_uE{&%1E
zmB>&<rt?|f?-oyzO{;qQd_RI1UtY=1=8At<A4?e!G@>S}eMRk+Vj~0J<8h8HWy+_a
ze!_K$t%f@^vV(gu9-A~5cFQ9^CHr&fQC?iaRBg|1N<>h<UPtdzg`s1ysVmx)o0;wK
z%Iw01I6>*GJIY)165(?nrv>S5tDp4|tt$`O@n$AZT^m26*a-M8KbsmuI!-ytoj-Zu
z9WI-nRGqtb3tPMNh#Iw~TKwL+#iF8PbN={7Rf%M9SVz0oOJ0MP=0bI4u2J>{YBj4i
zJTg_7ot^D$hQDW00Wd<s;>J4+&yRW0<+^Zr`zuCTRJh7H@~ukSOokXt><Q*F>I%JE
z#V|)#@MP5|*5(AMetD)`I7gZfcb19?5s*C7*s5nO>^Oi~vf2(G_te~yTU=ugi@2|3
z?RIr8y!;!6dtP8Dil!`l_D6S~Ik%IpCHE`h-oNe%&_Q2_$C43hU}b3#P$NZ=g&JxU
zX{{fF8jp;}4sHdJ7L*6~ghVR~D&+q4fb>_t(+L<1#sz$H5+f4_44gSR5dVrH3UbZ~
zuTTVmoOl?3bw*)3Drw*F9EbHcHo3YkiD<H0f3mm#Ntv=pZ(w*S?EUg^#s(ohrK-En
zOh;u<lH)Wbtz>9WzDCP%^RuD1R|2QC(<N^4=EGFr&a}?LvUeD3qvqOA$HzWSO;d=d
zIUy@4hPMlr^l7|nDCdFOdx4Vg+%2X1=TsnSNY)F4xk!+MiB*@l#KHF)fE;EX0(ji^
z;I#WGH<THjyaR{9q7lHu3dw3)&q|0`P3r}aLCgYg6cyAU1fj^G#$1TXK|?6~9Rfmj
zZf+frH=_nAA!Hz7-~cI1Dm@7FS0Rqog8>F3hymzu9-u$zNcFAM5C(|7`)CzTzn_iX
zfcw|GU^dwZ7)%y$N#zG5BPpxJ3X2bt8Z4@%fCMRJ<OeC-t5`Ys6kFwR5OB8o%mGLI
zMgIY^`_lY?W6=PRGwg?<+rwKif#U?G14F?8lL20SaS>vlp^=nm?H4hz9`Vj@qniD}
zC4)1O|GAC=e$8@!?xR3iv-19w0p^>fA<NmK09o@Eb;zc*7(;fZ<qBl2-xxu*_>DDW
z$?=Ym#o(=J4_`k4BHjf0#NEmXA7uvoTbP0Kt!zB|tV72;F#G>MxJVy1kjMg__D(?B
z*Pu2N1!-4W*&&FgjT8R;Bm}9q2|@1khw230fd%rj!C)f)_XS#9B$*-*iRS|H+BhI>
zBdF!jg0#zR{HXm@KJ?Ou=7A?o9C*^?JEUa-&;&H(|1!_z+c+{9%#s`iQ#{1^Y5sS*
zG(Z7C0E*E?;Dqm5LNO|=XaVYW8Ys@6g$L^S5BabJ6xvVn><{Qa3l9bZOZoHQB5Rz0
zxOSoaNdr{2bHbgRf!=m*=yeHvO>qX$z3hNM#{t8rgA>kv5kPzL1IZnXkY_W^quj;d
zj9dpRRsG|4zlRVQh)C)XhTI`LIpLHZAfy2-chf-HIez4KJ+S(-pdNil`{NQw<N}nu
zSOJ@^1F{CI=UzJ{3>M1>{(?9}j`xBBu@XffuUuX%l|7)xk6=cp4iQTOL82(I8+80n
z3e&EG!jmA`7xb)gh};tldF2Q_0W|%c0$*6C?Okx?Wg@}5!yz(t7=Z4QgTiNf+xHcL
zMLqe?kWONu@a0_x{oC8c2_KIHa?1DsWH$q(O*|v-eI3+NgIeW70czuci3C+Zy@Lko
z%!F=EctRqSAh8<_LAxNNm;yq4fLhOiJ108zxA|akqF`~dhuo3!Ag#<}28n+!;{R+h
zheX5q09m2@e*~dIQ|8X#e<2QP7)<4mp#BLsdkmoLB6>ODfu&%vQhx@tw)uHr2AJJb
zaGVYg=(TdFqqzI{pk5KC(5GPsd&OhFltTf$D?uU`;N8s$1<CB=gm+g#m3`<FhO_`o
zC3C+=cR;PuA?@)xfTv#%(p~Q7gp*zz^hiDZ{%}Ju5rmar9l(zf0NnsD<nr+5_>WIq
QWdCb$t3)5+ZQ2L_2aDlty8r+H

delta 5376
zcma)Ac{o&W`yXTd+PATeC0WMKSj*DOWGDMpijX~wooH-P6mgWwnk<PdS<=`ICS-{s
zOV%t|Lb9~T?>N41-=FJ!|9H=J&2>NLb3XUyzVGLG&U2l6h`FTkPe|!Z3`ohSVK6Ex
zn2e!!3Y{<&Xmnq8+MrTYY+1QB{WkqbVE=H0K+e+>q=)7W3NpJghXxQMnK`so^l*PT
z1jLdpLV!1UJ_J-Ds8}c<M4WyU&IEFGO(S^R=gD9&PB6X<Ak)GIh%@owR{U8kSr4ve
zI1_?;o|x$C-=KoK|F{{6@S+wQ&@W&RG?9qL8~Fe?oRz#3s}YEtJ?;HA+9ZOt`l%QK
zM@!%9-~-flu+rn+#4(q!FO7?V{ok|v`&Xw9etl<;+~2b$NZo!Kg2Aw8%V)MfO;A$U
z6WU6nKsbGskqTxJ6SmC6S#92rv${=&)h_!>uTS6aTuf3if1hUv_t4;~Ce37P2b*16
zeQJY<w2DZ<x~GiHNj)=yM65-&rv|k<qA;O{8jdNvg4aRF>)?x6_mak|G+X0jhnQJz
ztlswR<C5d_8|z%nPkD$&nrHVI=42>tQHK$|L=Xn2I=!^p7kEzM(pk<)R6YpS+NpNh
zntmjJ8>~PD%~C5C#a<A%tdK(ojn=ue8>%Qex}0sO50I#H5mxm6<i;-lJa&cZWC_1T
zfr`gGwYT0`g&R>d(mgsN@$9Jri;rrxY_|}VDF4lTPJ(`io6C98gm<Mg!b5GgL0>+u
z-b}NZ-p|(UbWkqV#97&R*Q9qn>=F2EHtF1y>tJvr#?)Fl&eLFg`_+8Fm3Ph-uBEvJ
zrIoK^uP}Kq4fr7<uRdoihl$E{aZ35ra9#1k3nmzBJ&TrF$Yu-7{W119tYZ0;&S&3?
zZHBgS7krnTLbe^tMvLxO(3~?%n_dpnHrO^W=c(6NQhGk&KlmC~6q=qOej4pC<mDcl
z9-ZV`o%+q~b4AJ!*7C>XL~aplKpENfLWfr_Ru)t$9#yBUWaO$|bOkY}B(23R4z*Fc
zdO6*Hv7sMG@V`BOlb$kE&yI)O4j}0j|M0**ZpIOpe`f5tqXtnxeE`eD_iRs>NUVE2
z%fgcrZ5tlfABb$hv5Pgm!<zdwwT*~1z1@^-8roF5Zh|!+ChzHK1gtSUjC!}z3~yvM
zpl7d|_>7cdx5*qUyGyDgT<$QQ@bs&K0UZwQv{)d=nWXixNjIV@V5G8Jm+1MeM><ep
zKi4ze#_OSOqkuvloxs!SOe2+@hH%46zj*pXV#1&5sbp+z;B18o;*ynGPTglLi>)@h
zBSC$kgu~DKzAGbN#J#W%FOQN%bW?Ro4kJy#OjSbxSJM3B;0pAQId_8I%@Xp<LRv9M
zD{XfksX1fH3ZK5Tz?~vweaop2yqs5UZrrI+olRx3>NdJYr=<TV_51pM&JXEDQ<6-j
z$c)jO)bvU+_5co}+CL@rx>*?Ir=Id<Mzqs%W;t0s_G`V!qyg8)gYn8_3u#gQXz#KW
zMlFUKw^G$e292-3Z8V3zVdRsw5;ykYxc+^iy)LTT(i&NXi_>R)?3q^f%0I@aF98{M
z*SpkWMegSsOFzChwlc2BTA3oHh<H1^%b1Z<eKj<8=hh@npjKTwK3c>6^)AOa>qP5c
zuV_-{*J-{dE=f54bl_)2<*m@~#KM~dvbilV9!x4<@)||*cl4iUS%lyAmFt`Oxog@V
zA<vQ$vE&Nh4|#h5qa3SIZ6cuYKvU&2ePJC7H)E&pa{SE+Dg9lhBwqMn|2AWoJ3=cn
zbL*3xz_XFhxJ}_Rwcgl?kDVG59R_vAy_CwUQKu=tUw(J4M}3k_hkea);-j{R<nGqc
zim)1Q?v=<U3OBVD=6o!*^iZO4^f}{lU%FYPNnY0!%{>H0xoy^Nc6ZpcK_6FskH%&&
zEUVt>QcALaaN9WD0p+oSRkt8i25(ihhDbO%9{c=O5)hOym^VEPCJY{r>_83&0_VhS
z&GdVC7!e96C-{G;iE$LUBQeURXO7Zi*?52UdHD~qb7OU$o+o|8*75Zv?QwoAsND!M
zc-l`2_Vc3c)g;$HCBvIWFJ7n>8``04R9bhRe4`{cmGSc6cmKW;NoHsBta3sdZ)S%X
zlES-Pw2>cU8aIzJ9IbV(WbR1Bw&P6i@>~!Up|D;sLz+&ctzAHuYFDxmHNpjxlDl!P
zn`X3piL-OqaCpw`8FOqnS58WYs}`Q8W6}9{IFh*Wg4X`#Y@%tnXq+_h?TzyG4NKGC
zk7(`LGo~0nXUK*dEcg&NvN)Q!iMtyStyqybzV;2wsZf!GdTRRHHi_r4uW`P1<2I;Q
zaaY7l{0oc6W3+m)0XnTI2Eab%Bw<U=oB(X46LsPjiwZ^jozhtawY}YxYP?M4Xhuc3
zWM~!<t31_)#P^25R^s;q$bSk86LXNfnUkk$${jqv=c&&v?OgG+l@FJTyBE=hT9#)D
zosgm1&5Q1|*e#77$h}uIhWpJ#ct_Olp~0&?mt+mxl%94~7{41>!RePyoA(7-xvDuF
ze6R6}r?@yiD{Ek);JS8=p;1N>eSQ$0&F3c#zFv-Rt2nGSd(&0>+DBBHmr+1}aP#vK
z79YL3PhQx11bJZZyTGUXwYjH$JP^Khd)|GRJ;STVk)yUbp_|W+d=Q6l(rOJ^e*XR%
zJ9fA@yxN&v+Ov;YXkj3ow`{K9%S>Yre$I_N;x%e1sU(+R?f0!C^=h5x=-V}%`I&}_
z1!@)UGJ2E=$K2zqR`J&C+xPg-FcJM*+s1yp2sG!r6c{+PIfz6zuA<(=r8@ORcmF)K
zLVGs@pON+O%^LHIeE&|Ily^#qc}AzTO%OSji^t(c!)oxC>^ovVF=i&bnJ@Hr@}x4H
zf6&u!cm0K6_ciSZRpsqSwxFFOie(cN5dI<OJIp!ev?jf6JB&9H638XK>W}1cpg21k
zyi4|qmwwTnan*hycKt*N&0ax*{jG1F4SCaV>RszT>>05(TgpZi;cW51xg9}+5j!o}
zCSQzwz>~eKgsC}(hP@}4WbI8I1g<T|vUJW8foru#REOx?|172A!0K06!cMmBndeJV
zPBZ%=IwtTzZtiouiY@x0lkL=w>(5+Eu?3)TUN~KMBL8w(+C;u_mU`vI%i5?3!j#1X
zF)pFmK>JH#{lXXpu6UNNLC=pYE1A8j-DM<QX%)r$bT6KD3I1Epn_8|<NUt$}M$lk^
zrZ6zkA=M|{k-TVf#z+Wn5iF^|FkD?nlI$y4jAt#k%-(S0VX}6)q_M7opC)O}zxZm{
z!uLeI2i}JVQ}vtNk?>WPf`$)+``FY_MI70xXdEvYH?NAprDmW`j!0(2nr}p%PPxQW
zJny@&zBzE<?s9#uD>QjQz)7|7ns)G7oa|@xbqs9*zCcJ@Up%z8;Fa(4a^zXAF3L%P
z;>>1$)V&fK#f$4#o_;Zu9vzkp^=u?l+?0!&-ukh;7bt5>sj`J9ib{Iz%n*w0BAUN?
zkgX2dOSo$l;W{T>qRUrHhaSx>_grTd@k(U%9SI^qC(iwvJl*Y6uU$R6A3|FyW=;3n
zH^O@ypMECDs$2F;<y*gB{MO07R?6{12vm94Grn1lMcM%V_Vudk`p?Q^Nof7pNHI}S
zB2Pu}SlPRM4M}m&?nT6s3%buM@8k|u1$-Exm$)TZL56FWx%yr4z`)qF@8!@#G?zHl
zox*EkRLKR`<Pc~3ZYVNl0nLtx)zN>2mqiPgy+iK^?_k~NuqY=SdGBId2A(o#NjPXJ
z%*=S(#F><Gaq#)fur9ge%7vNg6K%2`CiqG|cjV>!ly74!U92_hS7Ror*A%6&$#$&<
zuPfQ;R0DA=#%3O$YysmjC&OO;ZJh_vGHa_Hr~)d5?-S%*b*(tf%;bVw6_vL!2qdoo
z@~`HoC;oRH7QZrCf2USmHj?&5-XN$Gb8pAk=ke)<6DF#98ww_JQCJ4cm<HFVsd`lr
zk)O<0cQ*!5z_9x8&;@NGMN;pLoAYW2!3^UxY<L7Nfb^pOEtb-^U6k4La}q&|Nu}HV
z$bYfO$^)mfB!bv`B=`EzO;lsDw?wnu99;@!F%lQkTsLpC8%?qOP!Iornc}x6CmHm7
z$Cg*)%*>FEUDo`0F;;HnVdoCo?0th^gIl)a9c{PJv{$^lzeM({F7TfB?bu>0=(JQ_
zd7F`Q0v9EnG3How=lc@x8q-21{)0xm+KL*_<Ha6bYc*aMX9tVR+WF{0mrj8Hw}<6e
zZA0y4-u@vSj`-YAJJZmJ_GXJ4Q_4{X>7nP)=rlb>jeef?!SctK)qtgKt6t6Bvr}r$
z;vwt!G@<G6S^3XdOl3KvpT3`D@VKjPP^hj`J|bxo6Pn4Nw0whSO!IVXxCzNe6&%m{
zmJKofUQIY__rdXArK*t6iUn#q4$!pZ(12c<jRqQsV0NjY!HIJpj~WvaOUk2Gg~r;F
ziteyO@h&NfFoD5f=YXsBVs7Sry~d)wdX~C+Mm=wOB)Z=8&zbG?_M2}QNtnsVo61yF
zqZMn>@)o{9bfz+B8TmOeRCm9=k(6kyk+i;Hm)?7$zOGMVV!h&BZ;Wc@;r}mH4lvfe
zM^c;vU@RmF&}+|!OK$Wg$k4_HH|aA)r6NypRtJciIJ*zj3^1&rDg-g9chs-13C{%a
zg{lrpUH+ObbYATA{8@)!U%C_zIqWd}m1dWUs$SGrx|i^DC)zcFr+8mX%`>@6wiY6;
z^O3~IMf8p4YC(<DvtB%Hk|XyG1=rl?y(Bt~+x<9CyeoHJxER)B#NhIbEV$~CkC?)z
z{8KBOzjGt)r0c)S<<AGRls7rsp;f;v%b4XcBi{&3bt&xYM$TsEw3-$F;v2{ujpL5r
zuKe`TVlW!J2{$Gt{XSkS;N>7e3Km_J;cydvH~@s5K0^Sr^8uXxa5@@FjnFA@7%YYy
zNGX%7GIXtkh%Y<<5{P);laC4-)cNy~LW8j&m7@Vi*bq5{e8K%VBCkZfr-Tr~t+z)=
zdSVHrSEZHolo@)ok-K?>e0nl{G$0n%l0lCmOGuBD<H|OU9)(t3Jkl9`p>f3Fc{y-|
zY}8pCadhedQs%=_Dw6yywZWA=3;y_E0OP<3%l~C7y+Bv~m#s8^Yy*+NSxNtN?|@9R
z{Gaw6@M=DNxV?emW@*TdH!DJxwM8AWmM!NXTiD_QS&mjC$hx)KK$g&Y39^E1HuT54
zbs(Y51bXzbjT<h>2FSJ`00sgF{~_zxM=MzGzpv`377mce27bdb13m;=$p1Ql8_vlO
z`BxA)A?OVV`N=`hZ-Ou+sXP2qa0o2&BnJ$J`nMivtD~Zn0gW~!;Ly$m`9`#J!yjQF
z-}3g8e23|b_A!OzQh;3W8(QF)ZyK=KE(_^<@O#{?CV|1MNMSJLW1IlXzf-0KoI3=e
z7>OO+@axu43~6h6pr?Ztiu3270R2xM(-;PJI?()w+u)xU90mhR`EylAxjF!E?YRJC
zC+*>O1F)Uk@T-@Bq)r~_whX+@ybNr<;RHT)3PTVbksB`J44iO22^bMsAayg%zj&U4
z@5?S&t?D1`!&zdv0ut4MCgPELFX)SKgM9fTDF8!PHlVzR7SdQcN%vI;oCyO^NA{Qo
zi6`iQ1jIeq0nY9t@)>rw10vX-#IwL)YRAawUXc20Pb7f*n~d~itLz0;$HDBBj*(vl
z{7GfQpYcyBpB&$d%zzHwV1zTr9L9qo2ijoXKk5QuUFTEDVX%jEV5fA9%y|vi?2?Cy
z%k;AAF9M4z{EuZ`kNi6Y_CrNzf|I(r;j7U=a)|)Y+szF5Cu%5og@gVyp#SM(LE005
zgKk~OPrrv7{@^wwm(U{%K}{f}oeV+(z<$q>ls$v`;1jSoQLs3<V^W)sAz!mMyiiP?
zw=S!xATbjx?l^Hi|L>eB0AxO`go(jFC&A%f3lW~RZ~*^W<D!AVRE|Y>T?FnVJt#A^
zUT%0)DOjY`pGB>0sqlXQ27Cst)A2=(FaHy;sf_K<)Qgbm(sF{c;(A!lu|Q!jKnEls
z(ZdY|v+d)Ck5xe$G*#UHkuU&Ld3ZRxzd)T+$8>n>fayLRNJFfj8@~Ap((vd%dN~q6
gNVfrky8DHpNjrYr{-aeLHQ5XvzOodTTMohh1AP12XaE2J

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 546631a96c..ffb3eb366e 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Tue Mar 15 03:05:19 MSK 2016
+#Fri Jun 17 17:34:27 MSK 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.12-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.14-bin.zip
diff --git a/gradlew b/gradlew
index 9d82f78915..27309d9231 100755
--- a/gradlew
+++ b/gradlew
@@ -6,12 +6,30 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
 
 APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
@@ -30,6 +48,7 @@ die ( ) {
 cygwin=false
 msys=false
 darwin=false
+nonstop=false
 case "`uname`" in
   CYGWIN* )
     cygwin=true
@@ -40,26 +59,11 @@ case "`uname`" in
   MINGW* )
     msys=true
     ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
 esac
 
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 # Determine the Java command to use to start the JVM.
@@ -85,7 +89,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
diff --git a/gradlew.bat b/gradlew.bat
index 5f192121eb..832fdb6079 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -8,14 +8,14 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 

From fefe12dcf76c80000fac610463b40a894199d247 Mon Sep 17 00:00:00 2001
From: David Andrews <dta@alumni.cmu.edu>
Date: Fri, 17 Jun 2016 15:12:41 -0400
Subject: [PATCH 055/263] Wait until both subscribers have received their
 values in testPublishLast (#4021)

---
 src/test/java/rx/ObservableTests.java | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
index 0865047f3b..3dd215564a 100644
--- a/src/test/java/rx/ObservableTests.java
+++ b/src/test/java/rx/ObservableTests.java
@@ -498,21 +498,18 @@ public void run() {
         }).takeLast(1).publish();
 
         // subscribe once
-        final CountDownLatch latch = new CountDownLatch(1);
-        connectable.subscribe(new Action1<String>() {
+        final CountDownLatch latch = new CountDownLatch(2);
+        Action1<String> subscriptionAction = new Action1<String>() {
             @Override
             public void call(String value) {
                 assertEquals("last", value);
                 latch.countDown();
             }
-        });
+        };
+        connectable.subscribe(subscriptionAction);
 
         // subscribe twice
-        connectable.subscribe(new Action1<String>() {
-            @Override
-            public void call(String ignored) {
-            }
-        });
+        connectable.subscribe(subscriptionAction);
 
         Subscription subscription = connectable.connect();
         assertTrue(latch.await(1000, TimeUnit.MILLISECONDS));

From 8e127a5656b729f861247eb15b18690203059cba Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 17 Jun 2016 22:47:50 +0200
Subject: [PATCH 056/263] 1.x: update doOnEach(Observer) javadoc (#4024)

---
 src/main/java/rx/Observable.java | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 1d213bf6d0..9f0d9a71e3 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -4805,21 +4805,22 @@ public final Observable<T> doOnEach(final Action1<Notification<? super T>> onNot
     }
 
     /**
-     * Modifies the source Observable so that it notifies an Observer for each item it emits.
+     * Modifies the source Observable so that it notifies an Observer for each item and terminal event it emits.
      * <p>
      * In case the {@code onError} of the supplied observer throws, the downstream will receive a composite
      * exception containing the original exception and the exception thrown by {@code onError}. If either the
      * {@code onNext} or the {@code onCompleted} method of the supplied observer throws, the downstream will be
      * terminated and will receive this thrown exception.
      * <p>
-     * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/doOnEach.png" alt="">
+     * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/doOnEach.o.png" alt="">
      * <dl>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnEach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
      * @param observer
-     *            the action to invoke for each item emitted by the source Observable
+     *            the observer to be notified about onNext, onError and onCompleted events on its
+     *            respective methods before the actual downstream Subscriber gets notified.
      * @return the source Observable with the side-effecting behavior applied
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
      */

From 76517d9ac96d3f7f9475743c539e2b9efbd0d0f0 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 18 Jun 2016 17:21:05 +0200
Subject: [PATCH 057/263] 1.x: fix Completable.onErrorComplete(Func1) not
 relaying function crash (#4027)

---
 src/main/java/rx/Completable.java     |  3 ++-
 src/test/java/rx/CompletableTest.java | 25 +++++++++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index b5f9baebb7..69c0df708d 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -1663,8 +1663,9 @@ public void onError(Throwable e) {
                         try {
                             b = predicate.call(e);
                         } catch (Throwable ex) {
+                            Exceptions.throwIfFatal(ex);
                             e = new CompositeException(Arrays.asList(e, ex));
-                            return;
+                            b = false;
                         }
                         
                         if (b) {
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index a2a49d6c2d..4aee2eed85 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -4112,4 +4112,29 @@ public void onStart() {
         ts.assertCompleted();
     }
 
+    @Test
+    public void onErrorCompleteFunctionThrows() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+        
+        error.completable.onErrorComplete(new Func1<Throwable, Boolean>() {
+            @Override
+            public Boolean call(Throwable t) {
+                throw new TestException("Forced inner failure");
+            }
+        }).subscribe(ts);
+
+        ts.assertNoValues();
+        ts.assertNotCompleted();
+        ts.assertError(CompositeException.class);
+        
+        CompositeException composite = (CompositeException)ts.getOnErrorEvents().get(0);
+        
+        List<Throwable> errors = composite.getExceptions();
+        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.assertTrue(errors.get(1).toString(), errors.get(1) instanceof TestException);
+        Assert.assertEquals(errors.get(1).toString(), "Forced inner failure", errors.get(1).getMessage());
+    }
 }
\ No newline at end of file

From f17d3ff3b2edca2c5d9fa64df555068017ae9221 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 18 Jun 2016 17:53:36 +0200
Subject: [PATCH 058/263] 1.x: expand and explain cache() in more detail
 (#4026)

---
 src/main/java/rx/Observable.java | 80 ++++++++++++++++++++++++--------
 1 file changed, 61 insertions(+), 19 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 9f0d9a71e3..1babda6639 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -4027,27 +4027,48 @@ public final <B> Observable<List<T>> buffer(Observable<B> boundary, int initialC
     }
 
     /**
-     * Caches the emissions from the source Observable and replays them in order to any subsequent Subscribers.
-     * This method has similar behavior to {@link #replay} except that this auto-subscribes to the source
-     * Observable rather than returning a {@link ConnectableObservable} for which you must call
-     * {@code connect} to activate the subscription.
+     * Returns an Observable that subscribes to this Observable lazily, caches all of its events 
+     * and replays them, in the same order as received, to all the downstream subscribers.
      * <p>
      * <img width="640" height="410" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/cache.png" alt="">
      * <p>
      * This is useful when you want an Observable to cache responses and you can't control the
      * subscribe/unsubscribe behavior of all the {@link Subscriber}s.
      * <p>
-     * When you call {@code cache}, it does not yet subscribe to the source Observable and so does not yet
-     * begin caching items. This only happens when the first Subscriber calls the resulting Observable's
-     * {@code subscribe} method.
+     * The operator subscribes only when the first downstream subscriber subscribes and maintains
+     * a single subscription towards this Observable. In contrast, the operator family of {@link #replay()}
+     * that return a {@link ConnectableObservable} require an explicit call to {@link ConnectableObservable#connect()}.  
      * <p>
      * <em>Note:</em> You sacrifice the ability to unsubscribe from the origin when you use the {@code cache}
      * Observer so be careful not to use this Observer on Observables that emit an infinite or very large number
-     * of items that will use up memory.
+     * of items that will use up memory. 
+     * A possible workaround is to apply `takeUntil` with a predicate or
+     * another source before (and perhaps after) the application of cache().
+     * <pre><code>
+     * AtomicBoolean shouldStop = new AtomicBoolean();
+     * 
+     * source.takeUntil(v -&gt; shouldStop.get())
+     *       .cache()
+     *       .takeUntil(v -&gt; shouldStop.get())
+     *       .subscribe(...);
+     * </code></pre>
+     * Since the operator doesn't allow clearing the cached values either, the possible workaround is
+     * to forget all references to it via {@link #onTerminateDetach()} applied along with the previous
+     * workaround: 
+     * <pre><code>
+     * AtomicBoolean shouldStop = new AtomicBoolean();
+     * 
+     * source.takeUntil(v -&gt; shouldStop.get())
+     *       .onTerminateDetach()
+     *       .cache()
+     *       .takeUntil(v -&gt; shouldStop.get())
+     *       .onTerminateDetach()
+     *       .subscribe(...);
+     * </code></pre>
      * <dl>
      *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support upstream backpressure as it is purposefully requesting and caching
-     *      everything emitted.</dd>
+     *  <dd>The operator consumes this Observable in an unbounded fashion but respects the backpressure
+     *  of each downstream Subscriber individually.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code cache} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4070,27 +4091,48 @@ public final Observable<T> cache(int initialCapacity) {
     }
 
     /**
-     * Caches emissions from the source Observable and replays them in order to any subsequent Subscribers.
-     * This method has similar behavior to {@link #replay} except that this auto-subscribes to the source
-     * Observable rather than returning a {@link ConnectableObservable} for which you must call
-     * {@code connect} to activate the subscription.
+     * Returns an Observable that subscribes to this Observable lazily, caches all of its events 
+     * and replays them, in the same order as received, to all the downstream subscribers.
      * <p>
      * <img width="640" height="410" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/cache.png" alt="">
      * <p>
      * This is useful when you want an Observable to cache responses and you can't control the
      * subscribe/unsubscribe behavior of all the {@link Subscriber}s.
      * <p>
-     * When you call {@code cache}, it does not yet subscribe to the source Observable and so does not yet
-     * begin caching items. This only happens when the first Subscriber calls the resulting Observable's
-     * {@code subscribe} method.
+     * The operator subscribes only when the first downstream subscriber subscribes and maintains
+     * a single subscription towards this Observable. In contrast, the operator family of {@link #replay()}
+     * that return a {@link ConnectableObservable} require an explicit call to {@link ConnectableObservable#connect()}.  
      * <p>
      * <em>Note:</em> You sacrifice the ability to unsubscribe from the origin when you use the {@code cache}
      * Observer so be careful not to use this Observer on Observables that emit an infinite or very large number
      * of items that will use up memory.
+     * A possible workaround is to apply `takeUntil` with a predicate or
+     * another source before (and perhaps after) the application of cache().
+     * <pre><code>
+     * AtomicBoolean shouldStop = new AtomicBoolean();
+     * 
+     * source.takeUntil(v -&gt; shouldStop.get())
+     *       .cache()
+     *       .takeUntil(v -&gt; shouldStop.get())
+     *       .subscribe(...);
+     * </code></pre>
+     * Since the operator doesn't allow clearing the cached values either, the possible workaround is
+     * to forget all references to it via {@link #onTerminateDetach()} applied along with the previous
+     * workaround: 
+     * <pre><code>
+     * AtomicBoolean shouldStop = new AtomicBoolean();
+     * 
+     * source.takeUntil(v -&gt; shouldStop.get())
+     *       .onTerminateDetach()
+     *       .cache()
+     *       .takeUntil(v -&gt; shouldStop.get())
+     *       .onTerminateDetach()
+     *       .subscribe(...);
+     * </code></pre>
      * <dl>
      *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support upstream backpressure as it is purposefully requesting and caching
-     *      everything emitted.</dd>
+     *  <dd>The operator consumes this Observable in an unbounded fashion but respects the backpressure
+     *  of each downstream Subscriber individually.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code cache} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>

From 806aa2560b7ce7b30d7637e12ae8ce7819247470 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 18 Jun 2016 20:26:36 +0200
Subject: [PATCH 059/263] 1.x: make the latest CompositeSubscription test more
 robust. (#4019)

---
 .../CompositeSubscriptionTest.java            | 95 ++++++++++---------
 1 file changed, 50 insertions(+), 45 deletions(-)

diff --git a/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java b/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
index ec9190e8fa..4d3ebd753f 100644
--- a/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
+++ b/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
@@ -15,19 +15,16 @@
  */
 package rx.subscriptions;
 
-import org.junit.Test;
-import rx.Subscription;
-import rx.exceptions.CompositeException;
+import static org.junit.Assert.*;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.CountDownLatch;
+import java.util.*;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import org.junit.Test;
+
+import rx.Subscription;
+import rx.exceptions.CompositeException;
 
 public class CompositeSubscriptionTest {
 
@@ -395,7 +392,7 @@ public boolean isUnsubscribed() {
         assertEquals(4, counter.get());
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void testAddAllConcurrent() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
         final CompositeSubscription s = new CompositeSubscription();
@@ -404,46 +401,52 @@ public void testAddAllConcurrent() throws InterruptedException {
         final CountDownLatch start = new CountDownLatch(1);
         final CountDownLatch end = new CountDownLatch(10);
         final List<Thread> threads = new ArrayList<Thread>();
+        
+        final Queue<Throwable> errorQueue = new ConcurrentLinkedQueue<Throwable>();
+        
         for (int i = 0; i < count; i++) {
             final Thread t = new Thread() {
                 @Override
                 public void run() {
                     try {
-                        start.await();
-                        s.addAll(new Subscription() {
-                            @Override
-                            public void unsubscribe() {
-                                counter.incrementAndGet();
-                            }
-
-                            @Override
-                            public boolean isUnsubscribed() {
-                                return false;
-                            }
-                        }, new Subscription() {
-                            @Override
-                            public void unsubscribe() {
-                                counter.incrementAndGet();
-                            }
-
-                            @Override
-                            public boolean isUnsubscribed() {
-                                return false;
-                            }
-                        }, new Subscription() {
-                            @Override
-                            public void unsubscribe() {
-                                counter.incrementAndGet();
-                            }
-
-                            @Override
-                            public boolean isUnsubscribed() {
-                                return false;
-                            }
-                        });
+                        try {
+                            start.await();
+                            s.addAll(new Subscription() {
+                                @Override
+                                public void unsubscribe() {
+                                    counter.incrementAndGet();
+                                }
+    
+                                @Override
+                                public boolean isUnsubscribed() {
+                                    return false;
+                                }
+                            }, new Subscription() {
+                                @Override
+                                public void unsubscribe() {
+                                    counter.incrementAndGet();
+                                }
+    
+                                @Override
+                                public boolean isUnsubscribed() {
+                                    return false;
+                                }
+                            }, new Subscription() {
+                                @Override
+                                public void unsubscribe() {
+                                    counter.incrementAndGet();
+                                }
+    
+                                @Override
+                                public boolean isUnsubscribed() {
+                                    return false;
+                                }
+                            });
+                        } catch (final InterruptedException e) {
+                            errorQueue.offer(e);
+                        }
+                    } finally {
                         end.countDown();
-                    } catch (final InterruptedException e) {
-                        fail(e.getMessage());
                     }
                 }
             };
@@ -459,6 +462,8 @@ public boolean isUnsubscribed() {
         }
 
         assertEquals(30, counter.get());
+        
+        assertEquals(errorQueue.toString(), 0, errorQueue.size());
     }
 
 }

From c5a0c36fb37bab165332aaa8581f070fb58384bc Mon Sep 17 00:00:00 2001
From: Brandon Gogetap <bgogetap@gmail.com>
Date: Mon, 20 Jun 2016 00:17:28 -0500
Subject: [PATCH 060/263] Fix javadoc typos (#4038)

---
 src/main/java/rx/internal/util/UtilityFunctions.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/internal/util/UtilityFunctions.java b/src/main/java/rx/internal/util/UtilityFunctions.java
index cda1757ec1..5fe24cb75a 100644
--- a/src/main/java/rx/internal/util/UtilityFunctions.java
+++ b/src/main/java/rx/internal/util/UtilityFunctions.java
@@ -92,9 +92,9 @@ public Boolean call(Object o) {
      * @param <T4> the fifth argument type
      * @param <T5> the sixth argument type
      * @param <T6> the seventh argument type
-     * @param <T7> the eigth argument type
+     * @param <T7> the eighth argument type
      * @param <T8> the ninth argument type
-     * @param <T9> the thenth first argument type
+     * @param <T9> the tenth argument type
      * @param <R> the result type
      * @return a function that returns {@code null}
      */

From 6bef4cefb7b857735031fde29ad93e6746faadb9 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Mon, 20 Jun 2016 19:43:26 +0200
Subject: [PATCH 061/263] 1.x: distinctUntilChanged with direct value
 comparator - alternative (#4034)

* 1.x: distinctUntilChanged with direct value comparator - alternative

* Use primitive boolean

* Add experimental annotation
---
 src/main/java/rx/Observable.java              | 23 +++++++
 .../OperatorDistinctUntilChanged.java         | 30 ++++++++-
 .../OperatorDistinctUntilChangedTest.java     | 61 ++++++++++++++-----
 3 files changed, 97 insertions(+), 17 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 1babda6639..fc3e5714df 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -4804,6 +4804,29 @@ public final <U> Observable<T> distinctUntilChanged(Func1<? super T, ? extends U
         return lift(new OperatorDistinctUntilChanged<T, U>(keySelector));
     }
 
+    /**
+     * Returns an Observable that emits all items emitted by the source Observable that are distinct from their
+     * immediate predecessors when compared with each other via the provided comparator function.
+     * <p>
+     * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/distinctUntilChanged.png" alt="">
+     * <dl>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param comparator the function that receives the previous item and the current item and is
+     *                   expected to return true if the two are equal, thus skipping the current value.
+     * @return an Observable that emits those items from the source Observable that are distinct from their
+     *         immediate predecessors
+     * @see <a href="http://reactivex.io/documentation/operators/distinct.html">ReactiveX operators documentation: Distinct</a>
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical
+     *        with the release number)
+     */
+    @Experimental
+    public final Observable<T> distinctUntilChanged(Func2<? super T, ? super T, Boolean> comparator) {
+        return lift(new OperatorDistinctUntilChanged<T, T>(comparator));
+    }
+
     /**
      * Modifies the source Observable so that it invokes an action when it calls {@code onCompleted}.
      * <p>
diff --git a/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java b/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
index bbb60298cf..43529df76f 100644
--- a/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
+++ b/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
@@ -18,7 +18,7 @@
 import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.exceptions.Exceptions;
-import rx.functions.Func1;
+import rx.functions.*;
 import rx.internal.util.UtilityFunctions;
 
 /**
@@ -26,9 +26,11 @@
  * @param <T> the value type
  * @param <U> the key type
  */
-public final class OperatorDistinctUntilChanged<T, U> implements Operator<T, T> {
+public final class OperatorDistinctUntilChanged<T, U> implements Operator<T, T>, Func2<U, U, Boolean> {
     final Func1<? super T, ? extends U> keySelector;
     
+    final Func2<? super U, ? super U, Boolean> comparator;
+    
     private static class Holder {
         static final OperatorDistinctUntilChanged<?,?> INSTANCE = new OperatorDistinctUntilChanged<Object,Object>(UtilityFunctions.identity());
     }
@@ -48,6 +50,19 @@ public static <T> OperatorDistinctUntilChanged<T, T> instance() {
 
     public OperatorDistinctUntilChanged(Func1<? super T, ? extends U> keySelector) {
         this.keySelector = keySelector;
+        this.comparator = this;
+        
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public OperatorDistinctUntilChanged(Func2<? super U, ? super U, Boolean> comparator) {
+        this.keySelector = (Func1)UtilityFunctions.identity();
+        this.comparator = comparator;
+    }
+    
+    @Override
+    public Boolean call(U t1, U t2) {
+        return (t1 == t2 || (t1 != null && t1.equals(t2)));
     }
 
     @Override
@@ -68,7 +83,16 @@ public void onNext(T t) {
                 previousKey = key;
                 
                 if (hasPrevious) {
-                    if (!(currentKey == key || (key != null && key.equals(currentKey)))) {
+                    boolean comparison;
+                    
+                    try {
+                        comparison = comparator.call(currentKey, key);
+                    } catch (Throwable e) {
+                        Exceptions.throwOrReport(e, child, key);
+                        return;
+                    }
+                    
+                    if (!comparison) {
                         child.onNext(t);
                     } else {
                         request(1);
diff --git a/src/test/java/rx/internal/operators/OperatorDistinctUntilChangedTest.java b/src/test/java/rx/internal/operators/OperatorDistinctUntilChangedTest.java
index a913345026..eddee0cc09 100644
--- a/src/test/java/rx/internal/operators/OperatorDistinctUntilChangedTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDistinctUntilChangedTest.java
@@ -16,25 +16,19 @@
 package rx.internal.operators;
 
 import static org.junit.Assert.assertFalse;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 import static org.mockito.MockitoAnnotations.initMocks;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mock;
+import org.junit.*;
+import org.mockito.*;
 
-import rx.Observable;
-import rx.Observer;
-import rx.functions.Action1;
-import rx.functions.Func1;
+import rx.*;
+import rx.exceptions.TestException;
+import rx.functions.*;
+import rx.observers.TestSubscriber;
 
 public class OperatorDistinctUntilChangedTest {
 
@@ -164,4 +158,43 @@ public void call(Throwable t) {
           .subscribe(w);
         assertFalse(errorOccurred.get());
     }
+    
+    @Test
+    public void customComparator() {
+        Observable<String> source = Observable.just("a", "b", "B", "A","a", "C");
+        
+        TestSubscriber<String> ts = TestSubscriber.create();
+        
+        source.distinctUntilChanged(new Func2<String, String, Boolean>() {
+            @Override
+            public Boolean call(String a, String b) {
+                return a.compareToIgnoreCase(b) == 0;
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValues("a", "b", "A", "C");
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void customComparatorThrows() {
+        Observable<String> source = Observable.just("a", "b", "B", "A","a", "C");
+        
+        TestSubscriber<String> ts = TestSubscriber.create();
+        
+        source.distinctUntilChanged(new Func2<String, String, Boolean>() {
+            @Override
+            public Boolean call(String a, String b) {
+                throw new TestException();
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue("a");
+        ts.assertNotCompleted();
+        ts.assertError(TestException.class);
+    }
+
 }

From b8bccd981cf663ba14238839c39a92ebdb0b1233 Mon Sep 17 00:00:00 2001
From: Shyish <Shyish@users.noreply.github.com>
Date: Mon, 20 Jun 2016 19:54:41 +0200
Subject: [PATCH 062/263] Added zip function with Observable array. (#4036)

---
 src/main/java/rx/Observable.java              | 48 ++++++++++++++
 .../internal/operators/OperatorZipTest.java   | 62 +++++++++++++++++++
 2 files changed, 110 insertions(+)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index fc3e5714df..1be45f4066 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -3119,6 +3119,54 @@ public static <R> Observable<R> zip(Iterable<? extends Observable<?>> ws, FuncN<
         return Observable.just(os.toArray(new Observable<?>[os.size()])).lift(new OperatorZip<R>(zipFunction));
     }
 
+    /**
+     * Returns an Observable that emits the results of a specified combiner function applied to combinations of
+     * items emitted, in sequence, by an array of other Observables.
+     * <p>
+     * {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable
+     * will be the result of the function applied to the first item emitted by each of the source Observables;
+     * the second item emitted by the new Observable will be the result of the function applied to the second
+     * item emitted by each of those Observables; and so forth.
+     * <p>
+     * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@code onNext} as many times as
+     * the number of {@code onNext} invocations of the source Observable that emits the fewest items.
+     * <p>
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
+     * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
+     * source A completes and B has been consumed and is about to complete, the operator detects A won't
+     * be sending further values and it will unsubscribe B immediately. For example:
+     * <pre><code>zip(new Observable[]{range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2)}, (a) -&gt;
+     * a)</code></pre>
+     * {@code action1} will be called but {@code action2} won't.
+     * <br>To work around this termination property,
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
+     * or unsubscription.
+     * <p>
+     * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/zip.png" alt="">
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator expects backpressure from the sources and honors backpressure from the downstream.
+     *  (I.e., zipping with {@link #interval(long, TimeUnit)} may result in MissingBackpressureException, use
+     *  one of the {@code onBackpressureX} to handle similar, backpressure-ignoring sources.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param ws
+     *            an array of source Observables
+     * @param zipFunction
+     *            a function that, when applied to an item emitted by each of the source Observables, results in
+     *            an item that will be emitted by the resulting Observable
+     * @return an Observable that emits the zipped results
+     * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
+     */
+    @Experimental
+    public static <R> Observable<R> zip(Observable<?>[] ws, FuncN<? extends R> zipFunction) {
+        return Observable.just(ws).lift(new OperatorZip<R>(zipFunction));
+    }
+
     /**
      * Returns an Observable that emits the results of a specified combiner function applied to combinations of
      * <i>n</i> items emitted, in sequence, by the <i>n</i> Observables emitted by a specified Observable.
diff --git a/src/test/java/rx/internal/operators/OperatorZipTest.java b/src/test/java/rx/internal/operators/OperatorZipTest.java
index 75f83f3e67..5ba0adaa45 100644
--- a/src/test/java/rx/internal/operators/OperatorZipTest.java
+++ b/src/test/java/rx/internal/operators/OperatorZipTest.java
@@ -998,6 +998,68 @@ public Object call(final Object... args) {
         ts.assertReceivedOnNext(Collections.emptyList());
     }
 
+    @Test
+    public void testZipEmptyArray() {
+        Observable<Integer>[] ws = new Observable[0];
+        Observable<Integer> o = Observable.zip(ws, new FuncN<Integer>() {
+            @Override
+            public Integer call(Object... args) {
+                assertEquals("No argument should have been passed", 0, args.length);
+                return 0;
+            }
+        });
+
+        TestSubscriber<Object> ts = new TestSubscriber<Object>();
+        o.subscribe(ts);
+        ts.awaitTerminalEvent(200, TimeUnit.MILLISECONDS);
+        ts.assertReceivedOnNext(Collections.emptyList());
+    }
+
+    @Test
+    public void testZipArraySingleItem() {
+        final Integer expected = 0;
+        Observable<Integer>[] ws = new Observable[]{ Observable.just(expected) };
+
+        Observable<Integer> o = Observable.zip(ws, new FuncN<Integer>() {
+            @Override
+            public Integer call(Object... args) {
+                assertEquals("One argument should have been passed", 1, args.length);
+                return expected;
+            }
+        });
+
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        o.subscribe(ts);
+        ts.awaitTerminalEvent(200, TimeUnit.MILLISECONDS);
+        ts.assertReceivedOnNext(Collections.singletonList(expected));
+    }
+
+    @Test
+    public void testZipBigArray() {
+        final int size = 20;
+        Integer expected = 0;
+        Observable<Integer>[] ws = new Observable[size];
+
+        for (int i = 0, wsLength = ws.length; i < wsLength; i++) {
+            ws[i] = Observable.just(i);
+            expected += i;
+        }
+
+        final Integer finalExpected = expected;
+        Observable<Integer> o = Observable.zip(ws, new FuncN<Integer>() {
+            @Override
+            public Integer call(Object... args) {
+                assertEquals(size + " arguments should have been passed", size, args.length);
+                return finalExpected;
+            }
+        });
+
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        o.subscribe(ts);
+        ts.awaitTerminalEvent(200, TimeUnit.MILLISECONDS);
+        ts.assertReceivedOnNext(Collections.singletonList(expected));
+    }
+
     /**
      * Expect NoSuchElementException instead of blocking forever as zip should emit onCompleted and no onNext
      * and last() expects at least a single response.

From 0a5f884492ac0706630349fa7c2747ab98d5283d Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Mon, 20 Jun 2016 22:57:34 +0200
Subject: [PATCH 063/263] 1.x: add missing javadoc elements, fix some
 descriptions (#4039)

* 1.x: add missing javadoc elements, fix some descriptions

* Fix copy-paste error in Completable
---
 src/main/java/rx/Completable.java             |  18 +-
 src/main/java/rx/Observable.java              | 381 +++++++++++++++---
 .../operators/OperatorDoOnRequest.java        |   3 +-
 .../operators/OperatorSwitchIfEmpty.java      |   2 +-
 .../util/unsafe/MessagePassingQueue.java      |   2 +-
 5 files changed, 339 insertions(+), 67 deletions(-)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 69c0df708d..23c9dff907 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -474,7 +474,7 @@ public void call(CompletableSubscriber s) {
     /**
      * Returns a Completable instance that runs the given Action0 for each subscriber and
      * emits either an unchecked exception or simply completes.
-     * @param run the runnable to run for each subscriber
+     * @param action the Action0 to run for each subscriber
      * @return the new Completable instance
      * @throws NullPointerException if run is null
      */
@@ -725,6 +725,7 @@ public static Completable mergeDelayError(Observable<? extends Completable> sour
      * observable or any of the inner Completables until all of
      * them terminate in a way or another.
      * @param sources the sequence of Completables
+     * @param maxConcurrency the maximum number of simultaneous subscriptions to the source Completables.
      * @return the new Completable instance
      * @throws NullPointerException if sources is null
      */
@@ -764,10 +765,11 @@ public static Completable timer(long delay, TimeUnit unit) {
     }
     
     /**
-     * Returns a Completable instance that fires its onComplete event after the given delay elapsed
+     * Returns a Completable instance that fires its onCompleted event after the given delay elapsed
      * by using the supplied scheduler.
      * @param delay the delay time
      * @param unit the delay unit
+     * @param scheduler the scheduler to use to emit the onCompleted event
      * @return the new Completable instance
      */
     public static Completable timer(final long delay, final TimeUnit unit, final Scheduler scheduler) {
@@ -813,6 +815,7 @@ static NullPointerException toNpe(Throwable ex) {
      * <p>
      * This overload performs an eager unsubscription before the terminal event is emitted.
      * 
+     * @param <R> the resource type
      * @param resourceFunc0 the supplier that returns a resource to be managed. 
      * @param completableFunc1 the function that given a resource returns a Completable instance that will be subscribed to
      * @param disposer the consumer that disposes the resource created by the resource supplier
@@ -832,6 +835,7 @@ public static <R> Completable using(Func0<R> resourceFunc0,
      * If this overload performs a lazy unsubscription after the terminal event is emitted.
      * Exceptions thrown at this time will be delivered to RxJavaPlugins only.
      * 
+     * @param <R> the resource type
      * @param resourceFunc0 the supplier that returns a resource to be managed
      * @param completableFunc1 the function that given a resource returns a non-null
      * Completable instance that will be subscribed to
@@ -1108,6 +1112,7 @@ public final Completable compose(CompletableTransformer transformer) {
      * propagated to the downstream subscriber and will result in skipping the subscription of the 
      * Observable.  
      * 
+     * @param <T> the value type of the next Observable
      * @param next the Observable to subscribe after this Completable is completed, not null
      * @return Observable that composes this Completable and next
      * @throws NullPointerException if next is null
@@ -1127,6 +1132,7 @@ public final <T> Observable<T> andThen(Observable<T> next) {
      *  <dd>{@code andThen} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the value type of the next Single
      * @param next the Single to subscribe after this Completable is completed, not null
      * @return Single that composes this Completable and next
      */
@@ -1421,6 +1427,7 @@ public final Completable endWith(Completable other) {
     /**
      * Returns an Observable that first runs this Completable instance and
      * resumes with the given next Observable.
+     * @param <T> the value type of the next Observable
      * @param next the next Observable to continue
      * @return the new Observable instance
      * @deprecated Use {@link #andThen(rx.Observable)} instead.
@@ -1485,6 +1492,8 @@ public void onSubscribe(Subscription d) {
     /**
      * Subscribes to this Completable instance and blocks until it terminates or the specified timeout 
      * elapses, then returns null for normal termination or the emitted exception if any.
+     * @param timeout the time amount to wait for the terminal event
+     * @param unit the time unit of the timeout parameter
      * @return the throwable if this terminated with an error, null otherwise
      * @throws RuntimeException that wraps an InterruptedException if the wait is interrupted or
      * TimeoutException if the specified timeout elapsed before it
@@ -1845,6 +1854,7 @@ public final Completable startWith(Completable other) {
     /**
      * Returns an Observable which first delivers the events
      * of the other Observable then runs this Completable.
+     * @param <T> the value type of the starting other Observable
      * @param other the other Observable to run first
      * @return the new Observable instance
      * @throws NullPointerException if other is null
@@ -2201,6 +2211,7 @@ public final Completable timeout0(long timeout, TimeUnit unit, Scheduler schedul
     
     /**
      * Allows fluent conversion to another type via a function callback.
+     * @param <U> the output type as determined by the converter function
      * @param converter the function called with this which should return some other value.
      * @return the converted value
      * @throws NullPointerException if converter is null
@@ -2212,6 +2223,7 @@ public final <U> U to(Func1<? super Completable, U> converter) {
     /**
      * Returns an Observable which when subscribed to subscribes to this Completable and
      * relays the terminal events to the subscriber.
+     * @param <T> the target type of the Observable
      * @return the new Observable created
      */
     public final <T> Observable<T> toObservable() {
@@ -2226,6 +2238,7 @@ public void call(Subscriber<? super T> s) {
     /**
      * Converts this Completable into a Single which when this Completable completes normally,
      * calls the given supplier and emits its returned value through onSuccess.
+     * @param <T> the value type of the resulting Single
      * @param completionValueFunc0 the value supplier called when this Completable completes normally
      * @return the new Single instance
      * @throws NullPointerException if completionValueFunc0 is null
@@ -2273,6 +2286,7 @@ public void onSubscribe(Subscription d) {
     /**
      * Converts this Completable into a Single which when this Completable completes normally,
      * emits the given value through onSuccess.
+     * @param <T> the value type of the resulting Single
      * @param completionValue the value to emit when this Completable completes normally
      * @return the new Single instance
      * @throws NullPointerException if completionValue is null
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 1be45f4066..89624f40fd 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -122,7 +122,12 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
      *            on the class for convenience.  
      * @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the specified
      *         function
-     * @see {@link SyncOnSubscribe} {@code static create*} methods
+     * @see SyncOnSubscribe#createSingleState(Func0, Action2)
+     * @see SyncOnSubscribe#createSingleState(Func0, Action2, Action1)
+     * @see SyncOnSubscribe#createStateful(Func0, Func2)
+     * @see SyncOnSubscribe#createStateful(Func0, Func2, Action1)
+     * @see SyncOnSubscribe#createStateless(Action1)
+     * @see SyncOnSubscribe#createStateless(Action1, Action0)
      * @see <a href="http://reactivex.io/documentation/operators/create.html">ReactiveX operators documentation: Create</a>
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
@@ -158,7 +163,12 @@ public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe)
      *            on the class for convenience. 
      * @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the specified
      *         function
-     * @see {@link AsyncOnSubscribe AsyncOnSubscribe} {@code static create*} methods
+     * @see AsyncOnSubscribe#createSingleState(Func0, Action3)
+     * @see AsyncOnSubscribe#createSingleState(Func0, Action3, Action1)
+     * @see AsyncOnSubscribe#createStateful(Func0, Func3)
+     * @see AsyncOnSubscribe#createStateful(Func0, Func3, Action1)
+     * @see AsyncOnSubscribe#createStateless(Action2)
+     * @see AsyncOnSubscribe#createStateless(Action2, Action0)
      * @see <a href="http://reactivex.io/documentation/operators/create.html">ReactiveX operators documentation: Create</a>
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
@@ -189,6 +199,7 @@ public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<
      * returned as a single value. Note that it is legal for a conversion function to return an Observable
      * (enabling chaining). 
      * 
+     * @param <R> the output type of the conversion function
      * @param conversion a function that converts from this {@code Observable<T>} to an {@code R}
      * @return an instance of R created by the provided conversion function
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
@@ -200,7 +211,7 @@ public <R> R extend(Func1<? super OnSubscribe<T>, ? extends R> conversion) {
     
     /**
      * Transforms a OnSubscribe.call() into an Observable.subscribe() call.
-     * <p>Note: has to be in Observable because it calls the private subscribe() method 
+     * <p>Note: has to be in Observable because it calls the package-private subscribe() method 
      * @param <T> the value type
      */
     static final class OnSubscribeExtend<T> implements OnSubscribe<T> {
@@ -232,6 +243,7 @@ public void call(Subscriber<? super T> subscriber) {
      *  <dd>{@code lift} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the output value type
      * @param operator the Operator that implements the Observable-operating function to be applied to the source
      *             Observable
      * @return an Observable that is the result of applying the lifted Operator to the source Observable
@@ -255,6 +267,7 @@ public final <R> Observable<R> lift(final Operator<? extends R, ? super T> opera
      *  <dd>{@code compose} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the value type of the output Observable
      * @param transformer implements the function that transforms the source Observable
      * @return the source Observable, transformed by the transformer function
      * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Implementing-Your-Own-Operators">RxJava wiki: Implementing Your Own Operators</a>
@@ -265,8 +278,15 @@ public <R> Observable<R> compose(Transformer<? super T, ? extends R> transformer
     }
 
     /**
-     * Transformer function used by {@link #compose}.
-     * @warn more complete description needed
+     * Function that receives the current Observable and should return another
+     * Observable, possibly with given element type, in exchange that will be
+     * subscribed to by the downstream operators and subscribers.
+     * <p>
+     * This convenience interface has been introduced to work around the variance declaration
+     * problems of type arguments.
+     * 
+     * @param <T> the input Observable's value type
+     * @param <R> the output Observable's value type
      */
     public interface Transformer<T, R> extends Func1<Observable<T>, Observable<R>> {
         // cover for generics insanity
@@ -337,6 +357,7 @@ public Completable toCompletable() {
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element type
      * @param sources
      *            an Iterable of Observable sources competing to react first
      * @return an Observable that emits the same sequence as whichever of the source Observables first
@@ -357,6 +378,7 @@ public static <T> Observable<T> amb(Iterable<? extends Observable<? extends T>>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element type
      * @param o1
      *            an Observable competing to react first
      * @param o2
@@ -379,6 +401,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param o1
      *            an Observable competing to react first
      * @param o2
@@ -403,6 +426,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param o1
      *            an Observable competing to react first
      * @param o2
@@ -429,6 +453,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common element base type
      * @param o1
      *            an Observable competing to react first
      * @param o2
@@ -457,6 +482,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param o1
      *            an Observable competing to react first
      * @param o2
@@ -487,6 +513,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common element base type
      * @param o1
      *            an Observable competing to react first
      * @param o2
@@ -519,6 +546,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common element base type
      * @param o1
      *            an Observable competing to react first
      * @param o2
@@ -553,6 +581,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param o1
      *            an Observable competing to react first
      * @param o2
@@ -590,6 +619,9 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T1> the element type of the first source
+     * @param <T2> the element type of the second source
+     * @param <R> the combined output type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -616,6 +648,10 @@ public static <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the element type of the first source
+     * @param <T2> the element type of the second source
+     * @param <T3> the element type of the third source
+     * @param <R> the combined output type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -644,6 +680,11 @@ public static <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the element type of the first source
+     * @param <T2> the element type of the second source
+     * @param <T3> the element type of the third source
+     * @param <T4> the element type of the fourth source
+     * @param <R> the combined output type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -675,6 +716,12 @@ public static <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? exten
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the element type of the first source
+     * @param <T2> the element type of the second source
+     * @param <T3> the element type of the third source
+     * @param <T4> the element type of the fourth source
+     * @param <T5> the element type of the fifth source
+     * @param <R> the combined output type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -708,6 +755,13 @@ public static <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? e
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the element type of the first source
+     * @param <T2> the element type of the second source
+     * @param <T3> the element type of the third source
+     * @param <T4> the element type of the fourth source
+     * @param <T5> the element type of the fifth source
+     * @param <T6> the element type of the sixth source
+     * @param <R> the combined output type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -743,6 +797,14 @@ public static <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the element type of the first source
+     * @param <T2> the element type of the second source
+     * @param <T3> the element type of the third source
+     * @param <T4> the element type of the fourth source
+     * @param <T5> the element type of the fifth source
+     * @param <T6> the element type of the sixth source
+     * @param <T7> the element type of the seventh source
+     * @param <R> the combined output type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -780,6 +842,15 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observ
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the element type of the first source
+     * @param <T2> the element type of the second source
+     * @param <T3> the element type of the third source
+     * @param <T4> the element type of the fourth source
+     * @param <T5> the element type of the fifth source
+     * @param <T6> the element type of the sixth source
+     * @param <T7> the element type of the seventh source
+     * @param <T8> the element type of the eighth source
+     * @param <R> the combined output type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -819,6 +890,16 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Ob
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the element type of the first source
+     * @param <T2> the element type of the second source
+     * @param <T3> the element type of the third source
+     * @param <T4> the element type of the fourth source
+     * @param <T5> the element type of the fifth source
+     * @param <T6> the element type of the sixth source
+     * @param <T7> the element type of the seventh source
+     * @param <T8> the element type of the eighth source
+     * @param <T9> the element type of the ninth source
+     * @param <R> the combined output type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -936,6 +1017,7 @@ public static <T, R> Observable<R> combineLatestDelayError(Iterable<? extends Ob
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common element base type
      * @param observables
      *            an Observable that emits Observables
      * @return an Observable that emits items all of the items emitted by the Observables emitted by
@@ -957,6 +1039,7 @@ public static <T> Observable<T> concat(Observable<? extends Observable<? extends
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be concatenated
      * @param t2
@@ -979,6 +1062,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be concatenated
      * @param t2
@@ -1003,6 +1087,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be concatenated
      * @param t2
@@ -1029,6 +1114,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be concatenated
      * @param t2
@@ -1057,6 +1143,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be concatenated
      * @param t2
@@ -1087,6 +1174,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be concatenated
      * @param t2
@@ -1119,6 +1207,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be concatenated
      * @param t2
@@ -1153,6 +1242,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be concatenated
      * @param t2
@@ -1190,6 +1280,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param sources the Observable sequence of Observables
      * @return the new Observable with the concatenating behavior
      */
@@ -1210,6 +1301,7 @@ public static <T> Observable<T> concatDelayError(Observable<? extends Observable
      *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param sources the Iterable sequence of Observables
      * @return the new Observable with the concatenating behavior
      */
@@ -1883,6 +1975,7 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param sequences
      *            the Iterable of Observables
      * @return an Observable that emits items that are the result of flattening the items emitted by the
@@ -1906,6 +1999,7 @@ public static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param sequences
      *            the Iterable of Observables
      * @param maxConcurrent
@@ -1933,6 +2027,7 @@ public static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
+     * @param <T> the common element base type
      * @param source
      *            an Observable that emits Observables
      * @return an Observable that emits items that are the result of flattening the Observables emitted by the
@@ -1961,6 +2056,7 @@ public static <T> Observable<T> merge(Observable<? extends Observable<? extends
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param source
      *            an Observable that emits Observables
      * @param maxConcurrent
@@ -1992,6 +2088,7 @@ public static <T> Observable<T> merge(Observable<? extends Observable<? extends
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2016,6 +2113,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2042,6 +2140,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2070,6 +2169,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2100,6 +2200,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2132,6 +2233,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2166,6 +2268,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2202,6 +2305,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2240,6 +2344,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param sequences
      *            the Array of Observables
      * @return an Observable that emits all of the items emitted by the Observables in the Array
@@ -2262,6 +2367,7 @@ public static <T> Observable<T> merge(Observable<? extends T>[] sequences) {
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param sequences
      *            the Array of Observables
      * @param maxConcurrent
@@ -2292,6 +2398,7 @@ public static <T> Observable<T> merge(Observable<? extends T>[] sequences, int m
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param source
      *            an Observable that emits Observables
      * @return an Observable that emits all of the items emitted by the Observables emitted by the
@@ -2321,6 +2428,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends Observable<
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param source
      *            an Observable that emits Observables
      * @param maxConcurrent
@@ -2353,6 +2461,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends Observable<
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param sequences
      *            the Iterable of Observables
      * @return an Observable that emits items that are the result of flattening the items emitted by the
@@ -2381,6 +2490,7 @@ public static <T> Observable<T> mergeDelayError(Iterable<? extends Observable<?
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param sequences
      *            the Iterable of Observables
      * @param maxConcurrent
@@ -2412,6 +2522,7 @@ public static <T> Observable<T> mergeDelayError(Iterable<? extends Observable<?
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2442,6 +2553,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2474,6 +2586,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2508,6 +2621,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2544,6 +2658,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2583,6 +2698,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2623,6 +2739,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -2642,7 +2759,6 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      * @return an Observable that emits all of the items that are emitted by the source Observables
      * @see <a href="http://reactivex.io/documentation/operators/merge.html">ReactiveX operators documentation: Merge</a>
      */
-    // suppress because the types are checked by the method signature before using a vararg
     public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
         return mergeDelayError(just(t1, t2, t3, t4, t5, t6, t7, t8));
     }
@@ -2666,6 +2782,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
      * @param t2
@@ -3013,10 +3130,15 @@ public static Observable<Long> timer(long delay, TimeUnit unit, Scheduler schedu
      * <p>
      * <img width="640" height="400" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/using.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator is a pass-through for backpressure and otherwise depends on the 
+     *  backpressure support of the Observable returned by the {@code resourceFactory}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code using} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T> the element type of the generated Observable
+     * @param <Resource> the type of the resource associated with the output sequence
      * @param resourceFactory
      *            the factory function to create a resource object that depends on the Observable
      * @param observableFactory
@@ -3042,11 +3164,15 @@ public static <T, Resource> Observable<T> using(
      * <p>
      * <img width="640" height="400" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/using.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator is a pass-through for backpressure and otherwise depends on the 
+     *  backpressure support of the Observable returned by the {@code resourceFactory}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code using} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
-     * @warn "Backpressure Support" section missing from javadoc
+     * @param <T> the element type of the generated Observable
+     * @param <Resource> the type of the resource associated with the output sequence
      * @param resourceFactory
      *            the factory function to create a resource object that depends on the Observable
      * @param observableFactory
@@ -3103,6 +3229,7 @@ public static <T, Resource> Observable<T> using(
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the zipped result type
      * @param ws
      *            an Iterable of source Observables
      * @param zipFunction
@@ -3201,6 +3328,7 @@ public static <R> Observable<R> zip(Observable<?>[] ws, FuncN<? extends R> zipFu
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the zipped result type
      * @param ws
      *            an Observable of source Observables
      * @param zipFunction
@@ -3248,6 +3376,9 @@ public static <R> Observable<R> zip(Observable<? extends Observable<?>> ws, fina
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the value type of the first source
+     * @param <T2> the value type of the second source
+     * @param <R> the zipped result type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -3298,6 +3429,10 @@ public static <T1, T2, R> Observable<R> zip(Observable<? extends T1> o1, Observa
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the value type of the first source
+     * @param <T2> the value type of the second source
+     * @param <T3> the value type of the third source
+     * @param <R> the zipped result type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -3350,6 +3485,11 @@ public static <T1, T2, T3, R> Observable<R> zip(Observable<? extends T1> o1, Obs
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the value type of the first source
+     * @param <T2> the value type of the second source
+     * @param <T3> the value type of the third source
+     * @param <T4> the value type of the fourth source
+     * @param <R> the zipped result type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -3404,6 +3544,12 @@ public static <T1, T2, T3, T4, R> Observable<R> zip(Observable<? extends T1> o1,
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the value type of the first source
+     * @param <T2> the value type of the second source
+     * @param <T3> the value type of the third source
+     * @param <T4> the value type of the fourth source
+     * @param <T5> the value type of the fifth source
+     * @param <R> the zipped result type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -3459,6 +3605,13 @@ public static <T1, T2, T3, T4, T5, R> Observable<R> zip(Observable<? extends T1>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the value type of the first source
+     * @param <T2> the value type of the second source
+     * @param <T3> the value type of the third source
+     * @param <T4> the value type of the fourth source
+     * @param <T5> the value type of the fifth source
+     * @param <T6> the value type of the sixth source
+     * @param <R> the zipped result type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -3517,6 +3670,14 @@ public static <T1, T2, T3, T4, T5, T6, R> Observable<R> zip(Observable<? extends
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the value type of the first source
+     * @param <T2> the value type of the second source
+     * @param <T3> the value type of the third source
+     * @param <T4> the value type of the fourth source
+     * @param <T5> the value type of the fifth source
+     * @param <T6> the value type of the sixth source
+     * @param <T7> the value type of the seventh source
+     * @param <R> the zipped result type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -3577,6 +3738,15 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> zip(Observable<? ext
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the value type of the first source
+     * @param <T2> the value type of the second source
+     * @param <T3> the value type of the third source
+     * @param <T4> the value type of the fourth source
+     * @param <T5> the value type of the fifth source
+     * @param <T6> the value type of the sixth source
+     * @param <T7> the value type of the seventh source
+     * @param <T8> the value type of the eighth source
+     * @param <R> the zipped result type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -3639,6 +3809,16 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> zip(Observable<?
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T1> the value type of the first source
+     * @param <T2> the value type of the second source
+     * @param <T3> the value type of the third source
+     * @param <T4> the value type of the fourth source
+     * @param <T5> the value type of the fifth source
+     * @param <T6> the value type of the sixth source
+     * @param <T7> the value type of the seventh source
+     * @param <T8> the value type of the eighth source
+     * @param <T9> the value type of the ninth source
+     * @param <R> the zipped result type
      * @param o1
      *            the first source Observable
      * @param o2
@@ -3737,6 +3917,7 @@ public final Observable<T> asObservable() {
      *  <dd>This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <TClosing> the value type of the boundary-providing Observable
      * @param bufferClosingSelector
      *            a {@link Func0} that produces an Observable that governs the boundary between buffers.
      *            Whenever this {@code Observable} emits an item, {@code buffer} emits the current buffer and
@@ -3999,6 +4180,8 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler
      *  <dd>This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <TOpening> the element type of the buffer-opening Observable
+     * @param <TClosing> the element type of the individual buffer-closing Observables
      * @param bufferOpenings
      *            the Observable that, when it emits an item, causes a new buffer to be created
      * @param bufferClosingSelector
@@ -4130,6 +4313,10 @@ public final Observable<T> cache() {
     }
 
     /**
+     * Caches and shares everything from this Observable and uses the initialCapacity to
+     * reduce the number of times the internal buffer needs resizing.
+     * @param initialCapacity the capacity to start with
+     * @return the new Observable instance with the specific behavior.
      * @see #cacheWithInitialCapacity(int)
      * @deprecated Use {@link #cacheWithInitialCapacity(int)} instead.
      */
@@ -4207,6 +4394,7 @@ public final Observable<T> cacheWithInitialCapacity(int initialCapacity) {
      *  <dd>{@code cast} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the output value type cast to
      * @param klass
      *            the target class type that {@code cast} will cast the items emitted by the source Observable
      *            into before emitting them from the resulting Observable
@@ -4233,6 +4421,7 @@ public final <R> Observable<R> cast(final Class<R> klass) {
      *  <dd>{@code collect} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the accumulator and output type
      * @param stateFactory
      *           the mutable data structure that will collect the items
      * @param collector
@@ -4265,6 +4454,7 @@ public final <R> Observable<R> collect(Func0<R> stateFactory, final Action2<R, ?
      *  <dd>{@code concatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the type of the inner Observable sources and thus the ouput type
      * @param func
      *            a function that, when applied to an item emitted by the source Observable, returns an
      *            Observable
@@ -4717,6 +4907,7 @@ public final Observable<T> delaySubscription(long delay, TimeUnit unit, Schedule
      *  <dd>This method does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <U> the element type of the delaying Observable
      * @param subscriptionDelay
      *            a function that returns an Observable that triggers the subscription to the source Observable
      *            once it emits any item
@@ -4764,7 +4955,8 @@ public final <U> Observable<T> delaySubscription(Observable<U> other) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code dematerialize} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
+     * @param <T2> the output value type
      * @return an Observable that emits the items and notifications embedded in the {@link Notification} objects
      *         emitted by the source Observable
      * @throws OnErrorNotImplementedException
@@ -4803,6 +4995,7 @@ public final Observable<T> distinct() {
      *  <dd>{@code distinct} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <U> the key type
      * @param keySelector
      *            a function that projects an emitted item to a key value that is used to decide whether an item
      *            is distinct from another one or not
@@ -4841,6 +5034,7 @@ public final Observable<T> distinctUntilChanged() {
      *  <dd>{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <U> the key type
      * @param keySelector
      *            a function that projects an emitted item to a key value that is used to decide whether an item
      *            is distinct from another one or not
@@ -5107,8 +5301,7 @@ public final Observable<T> doOnUnsubscribe(final Action0 unsubscribe) {
      * @param <T> the value type 
      * @param o1 the first source
      * @param o2 the second source
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5134,8 +5327,7 @@ public static <T> Observable<T> concatEager(Observable<? extends T> o1, Observab
      * @param o1 the first source
      * @param o2 the second source
      * @param o3 the third source
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5165,8 +5357,7 @@ public static <T> Observable<T> concatEager(
      * @param o2 the second source
      * @param o3 the third source
      * @param o4 the fourth source
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5197,8 +5388,7 @@ public static <T> Observable<T> concatEager(
      * @param o3 the third source
      * @param o4 the fourth source
      * @param o5 the fifth source
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5231,8 +5421,7 @@ public static <T> Observable<T> concatEager(
      * @param o4 the fourth source
      * @param o5 the fifth source
      * @param o6 the sixth source
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5266,8 +5455,7 @@ public static <T> Observable<T> concatEager(
      * @param o5 the fifth source
      * @param o6 the sixth source
      * @param o7 the seventh source
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5303,8 +5491,7 @@ public static <T> Observable<T> concatEager(
      * @param o6 the sixth source
      * @param o7 the seventh source
      * @param o8 the eighth source
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5341,8 +5528,7 @@ public static <T> Observable<T> concatEager(
      * @param o7 the seventh source
      * @param o8 the eighth source
      * @param o9 the ninth source
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5372,8 +5558,7 @@ public static <T> Observable<T> concatEager(
      * </dl>
      * @param <T> the value type
      * @param sources a sequence of Observables that need to be eagerly concatenated
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5398,8 +5583,7 @@ public static <T> Observable<T> concatEager(Iterable<? extends Observable<? exte
      * @param <T> the value type
      * @param sources a sequence of Observables that need to be eagerly concatenated
      * @param capacityHint hints about the number of expected source sequence values
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5423,8 +5607,7 @@ public static <T> Observable<T> concatEager(Iterable<? extends Observable<? exte
      * </dl>
      * @param <T> the value type
      * @param sources a sequence of Observables that need to be eagerly concatenated
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5449,8 +5632,7 @@ public static <T> Observable<T> concatEager(Observable<? extends Observable<? ex
      * @param <T> the value type
      * @param sources a sequence of Observables that need to be eagerly concatenated
      * @param capacityHint hints about the number of expected source sequence values
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5476,8 +5658,7 @@ public static <T> Observable<T> concatEager(Observable<? extends Observable<? ex
      * @param <R> the value type
      * @param mapper the function that maps a sequence of values into a sequence of Observables that will be
      *               eagerly concatenated
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5503,8 +5684,7 @@ public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observa
      * @param mapper the function that maps a sequence of values into a sequence of Observables that will be
      *               eagerly concatenated
      * @param capacityHint hints about the number of expected source sequence values
-     * @return 
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5534,8 +5714,7 @@ public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observa
      *               eagerly concatenated
      * @param capacityHint hints about the number of expected source sequence values
      * @param maxConcurrent the maximum number of concurrent subscribed observables
-     * @return
-     * @warn javadoc fails to describe the return value
+     * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
@@ -5777,6 +5956,7 @@ public final Observable<T> firstOrDefault(T defaultValue, Func1<? super T, Boole
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the value type of the inner Observables and the output type
      * @param func
      *            a function that, when applied to an item emitted by the source Observable, returns an
      *            Observable
@@ -5804,6 +5984,7 @@ public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? e
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the value type of the inner Observables and the output type
      * @param func
      *            a function that, when applied to an item emitted by the source Observable, returns an
      *            Observable
@@ -6219,6 +6400,10 @@ public final <K> Observable<GroupedObservable<K, T>> groupBy(final Func1<? super
      *  <dd>{@code groupJoin} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <T2> the value type of the right Observable source
+     * @param <D1> the element type of the left duration Observables
+     * @param <D2> the element type of the right duration Observables
+     * @param <R> the result type
      * @param right
      *            the other Observable to correlate items from the source Observable with
      * @param leftDuration
@@ -6288,6 +6473,10 @@ public final Observable<Boolean> isEmpty() {
      *  <dd>{@code join} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <TRight> the value type of the right Observable source
+     * @param <TLeftDuration> the element type of the left duration Observables
+     * @param <TRightDuration> the element type of the right duration Observables
+     * @param <R> the result type
      * @param right
      *            the second Observable to join items from
      * @param leftDurationSelector
@@ -6427,6 +6616,7 @@ public final Observable<T> limit(int count) {
      *  <dd>{@code map} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the output type
      * @param func
      *            a function to apply to each item emitted by the Observable
      * @return an Observable that emits the items from the source Observable, transformed by the specified
@@ -6482,7 +6672,7 @@ public final Observable<T> mergeWith(Observable<? extends T> t1) {
     
     /**
      * Modifies an Observable to perform its emissions and notifications on a specified {@link Scheduler},
-     * asynchronously with a bounded buffer of {@link RxRingBuffer.SIZE} slots.
+     * asynchronously with a bounded buffer of {@link rx.internal.util.RxRingBuffer#SIZE} slots.
      *
      * <p>Note that onError notifications will cut ahead of onNext notifications on the emission thread if Scheduler is truly
      * asynchronous. If strict event ordering is required, consider using the {@link #observeOn(Scheduler, boolean)} overload.
@@ -6510,8 +6700,7 @@ public final Observable<T> observeOn(Scheduler scheduler) {
 
     /**
      * Modifies an Observable to perform its emissions and notifications on a specified {@link Scheduler},
-     * asynchronously with a bounded buffer of configurable size other than the {@link RxRingBuffer.SIZE}
-     * default.
+     * asynchronously with a bounded buffer of configurable size.
      *
      * <p>Note that onError notifications will cut ahead of onNext notifications on the emission thread if Scheduler is truly
      * asynchronous. If strict event ordering is required, consider using the {@link #observeOn(Scheduler, boolean)} overload.
@@ -6568,8 +6757,7 @@ public final Observable<T> observeOn(Scheduler scheduler, boolean delayError) {
 
     /**
      * Modifies an Observable to perform its emissions and notifications on a specified {@link Scheduler},
-     * asynchronously with a bounded buffer of configurable size other than the {@link RxRingBuffer.SIZE}
-     * default, and optionally delays onError notifications.
+     * asynchronously with a bounded buffer of configurable size and optionally delays onError notifications.
      * <p>
      * <img width="640" height="308" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/observeOn.png" alt="">
      * <dl>
@@ -6609,6 +6797,7 @@ public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, in
      *  <dd>{@code ofType} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the output type
      * @param klass
      *            the class type to filter the items emitted by the source Observable
      * @return an Observable that emits items from the source Observable of type {@code klass}
@@ -7056,6 +7245,7 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
      *  <dd>{@code reduce} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the accumulator and output value type
      * @param initialValue
      *            the initial (seed) accumulator value
      * @param accumulator
@@ -7794,7 +7984,7 @@ public final Observable<T> retry(Func2<Integer, Throwable, Boolean> predicate) {
      * 
      * This retries 3 times, each time incrementing the number of seconds it waits.
      * 
-     * <pre> {@code
+     * <pre><code>
      *  Observable.create((Subscriber<? super String> s) -> {
      *      System.out.println("subscribing");
      *      s.onError(new RuntimeException("always fails"));
@@ -7804,7 +7994,7 @@ public final Observable<T> retry(Func2<Integer, Throwable, Boolean> predicate) {
      *          return Observable.timer(i, TimeUnit.SECONDS);
      *      });
      *  }).toBlocking().forEach(System.out::println);
-     * } </pre>
+     * </code></pre>
      * 
      * Output is:
      *
@@ -7927,6 +8117,7 @@ public final Observable<T> sample(long period, TimeUnit unit, Scheduler schedule
      *  <dd>This version of {@code sample} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <U> the element type of the sampler Observable
      * @param sampler
      *            the Observable to use for sampling the source Observable
      * @return an Observable that emits the results of sampling the items emitted by this Observable whenever
@@ -7980,6 +8171,7 @@ public final Observable<T> scan(Func2<T, T, T> accumulator) {
      *  <dd>{@code scan} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the initial, accumulator and result type
      * @param initialValue
      *            the initial (seed) accumulator item
      * @param accumulator
@@ -8292,6 +8484,7 @@ public final Observable<T> skipLast(long time, TimeUnit unit, Scheduler schedule
      *  <dd>{@code skipUntil} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <U> the element type of the other Observable
      * @param other
      *            the second Observable that has to emit an item before the source Observable's elements begin
      *            to be mirrored by the resulting Observable
@@ -8935,6 +9128,7 @@ public final Observable<T> subscribeOn(Scheduler scheduler) {
      *  <dd>{@code switchMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the element type of the inner Observables and the output
      * @param func
      *            a function that, when applied to an item emitted by the source Observable, returns an
      *            Observable
@@ -8960,6 +9154,7 @@ public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<?
      *  <dd>{@code switchMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <R> the element type of the inner Observables and the output
      * @param func
      *            a function that, when applied to an item emitted by the source Observable, returns an
      *            Observable
@@ -9365,7 +9560,14 @@ public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate)
      * The difference between this operator and {@link #takeWhile(Func1)} is that here, the condition is
      * evaluated <em>after</em> the item is emitted.
      * 
-     * @warn "Scheduler" and "Backpressure Support" sections missing from javadocs
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator is a pass-through for backpressure; the backpressure behavior is determined by the upstream
+     *  source and the downstream consumer.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code takeWhile} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * 
      * @param stopPredicate 
      *            a function that evaluates an item emitted by the source Observable and returns a Boolean
      * @return an Observable that first emits items emitted by the source Observable, checks the specified
@@ -9933,6 +10135,7 @@ public final Observable<List<T>> toList() {
      *  <dd>{@code toMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <K> the key type of the Map
      * @param keySelector
      *            the function that extracts the key from a source item to be used in the HashMap
      * @return an Observable that emits a single item: a HashMap containing the mapped items from the source
@@ -9958,6 +10161,8 @@ public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySe
      *  <dd>{@code toMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <K> the key type of the Map
+     * @param <V> the value type of the Map
      * @param keySelector
      *            the function that extracts the key from a source item to be used in the HashMap
      * @param valueSelector
@@ -9982,6 +10187,8 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      *  <dd>{@code toMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <K> the key type of the Map
+     * @param <V> the value type of the Map
      * @param keySelector
      *            the function that extracts the key from a source item to be used in the Map
      * @param valueSelector
@@ -10008,6 +10215,7 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <K> the key type of the Map
      * @param keySelector
      *            the function that extracts the key from the source items to be used as key in the HashMap
      * @return an Observable that emits a single item: a HashMap that contains an ArrayList of items mapped from
@@ -10031,6 +10239,8 @@ public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ?
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <K> the key type of the Map
+     * @param <V> the value type of the Map
      * @param keySelector
      *            the function that extracts a key from the source items to be used as key in the HashMap
      * @param valueSelector
@@ -10056,6 +10266,8 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <K> the key type of the Map
+     * @param <V> the value type of the Map
      * @param keySelector
      *            the function that extracts a key from the source items to be used as the key in the Map
      * @param valueSelector
@@ -10083,6 +10295,8 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <K> the key type of the Map
+     * @param <V> the value type of the Map
      * @param keySelector
      *            the function that extracts a key from the source items to be used as the key in the Map
      * @param valueSelector
@@ -10159,13 +10373,13 @@ public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Intege
      *  <dd>{@code toSortedList} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
-     * @throws ClassCastException
-     *             if any item emitted by the Observable does not implement {@link Comparable} with respect to
-     *             all other items emitted by the Observable
      * @param initialCapacity 
      *             the initial capacity of the ArrayList used to accumulate items before sorting
      * @return an Observable that emits a list that contains the items emitted by the source Observable in
      *         sorted order
+     * @throws ClassCastException
+     *             if any item emitted by the Observable does not implement {@link Comparable} with respect to
+     *             all other items emitted by the Observable
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
@@ -10224,9 +10438,18 @@ public final Observable<T> unsubscribeOn(Scheduler scheduler) {
      * function only when the source Observable (this instance) emits an item.
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/withLatestFrom.png" alt="">
-     *
-     * @warn "Backpressure Support" section missing from javadoc
-     * @warn "Scheduler" section missing from javadoc
+     * 
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator is a pass-through for backpressure: the backpressure support
+     *  depends on the upstream and downstream's backpressure behavior. The other Observable
+     *  is consumed in an unbounded fashion.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>This operator, by default, doesn't run any particular {@link Scheduler}.</dd>
+     * </dl>
+     * 
+     * @param <U> the element type of the other Observable
+     * @param <R> the result type of the combination
      * @param other
      *            the other Observable
      * @param resultSelector
@@ -10264,7 +10487,8 @@ public final <U, R> Observable<R> withLatestFrom(Observable<? extends U> other,
      * @param <T1> the first other source's value type
      * @param <T2> the second other source's value type
      * @param <R> the result value type
-     * @param others the array of other sources
+     * @param o1 the first other Observable
+     * @param o2 the second other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
      * @Experimental The behavior of this can change at any time.
@@ -10296,7 +10520,9 @@ public final <T1, T2, R> Observable<R> withLatestFrom(Observable<T1> o1, Observa
      * @param <T2> the second other source's value type
      * @param <T3> the third other source's value type
      * @param <R> the result value type
-     * @param others the array of other sources
+     * @param o1 the first other Observable
+     * @param o2 the second other Observable
+     * @param o3 the third other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
      * @Experimental The behavior of this can change at any time.
@@ -10333,7 +10559,10 @@ public final <T1, T2, T3, R> Observable<R> withLatestFrom(
      * @param <T3> the third other source's value type
      * @param <T4> the fourth other source's value type
      * @param <R> the result value type
-     * @param others the array of other sources
+     * @param o1 the first other Observable
+     * @param o2 the second other Observable
+     * @param o3 the third other Observable
+     * @param o4 the fourth other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
      * @Experimental The behavior of this can change at any time.
@@ -10370,7 +10599,11 @@ public final <T1, T2, T3, T4, R> Observable<R> withLatestFrom(
      * @param <T4> the fourth other source's value type
      * @param <T5> the fifth other source's value type
      * @param <R> the result value type
-     * @param others the array of other sources
+     * @param o1 the first other Observable
+     * @param o2 the second other Observable
+     * @param o3 the third other Observable
+     * @param o4 the fourth other Observable
+     * @param o5 the fifth other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
      * @Experimental The behavior of this can change at any time.
@@ -10410,7 +10643,12 @@ public final <T1, T2, T3, T4, T5, R> Observable<R> withLatestFrom(
      * @param <T5> the fifth other source's value type
      * @param <T6> the sixth other source's value type
      * @param <R> the result value type
-     * @param others the array of other sources
+     * @param o1 the first other Observable
+     * @param o2 the second other Observable
+     * @param o3 the third other Observable
+     * @param o4 the fourth other Observable
+     * @param o5 the fifth other Observable
+     * @param o6 the sixth other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
      * @Experimental The behavior of this can change at any time.
@@ -10451,7 +10689,13 @@ public final <T1, T2, T3, T4, T5, T6, R> Observable<R> withLatestFrom(
      * @param <T6> the sixth other source's value type
      * @param <T7> the seventh other source's value type
      * @param <R> the result value type
-     * @param others the array of other sources
+     * @param o1 the first other Observable
+     * @param o2 the second other Observable
+     * @param o3 the third other Observable
+     * @param o4 the fourth other Observable
+     * @param o5 the fifth other Observable
+     * @param o6 the sixth other Observable
+     * @param o7 the seventh other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
      * @Experimental The behavior of this can change at any time.
@@ -10494,7 +10738,14 @@ public final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> withLatestFrom(
      * @param <T7> the seventh other source's value type
      * @param <T8> the eigth other source's value type
      * @param <R> the result value type
-     * @param others the array of other sources
+     * @param o1 the first other Observable
+     * @param o2 the second other Observable
+     * @param o3 the third other Observable
+     * @param o4 the fourth other Observable
+     * @param o5 the fifth other Observable
+     * @param o6 the sixth other Observable
+     * @param o7 the seventh other Observable
+     * @param o8 the eighth other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
      * @Experimental The behavior of this can change at any time.
@@ -10583,6 +10834,7 @@ public final <R> Observable<R> withLatestFrom(Iterable<Observable<?>> others, Fu
      *  <dd>This version of {@code window} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <TClosing> the element type of the boundary Observable
      * @param closingSelector
      *            a {@link Func0} that returns an {@code Observable} that governs the boundary between windows.
      *            When this {@code Observable} emits an item, {@code window} emits the current window and begins
@@ -10876,11 +11128,16 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit, Sche
      * <img width="640" height="550" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window2.png" alt="">
      * <dl>
      *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses Observables to control data flow.</dd>
+     *  <dd>The outer Observable of this operator doesn't support backpressure because the emission of new
+     *  inner Observables are controlled by the {@code windowOpenings} Observable. 
+     *  The inner Observables honor backpressure and buffer everything until the associated closing
+     *  Observable signals or completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * 
+     * @param <TOpening> the element type of the window-opening Observable
+     * @param <TClosing> the element type of the window-closing Observables
      * @param windowOpenings
      *            an Observable that, when it emits an item, causes another window to be created
      * @param closingSelector
@@ -10902,8 +11159,8 @@ public final <TOpening, TClosing> Observable<Observable<T>> window(Observable<?
      * <img width="640" height="475" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window8.png" alt="">
      * <dl>
      *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses a {@code boundary} Observable to control data
-     *      flow.</dd>
+     *  <dd>The outer Observable of this operator does not support backpressure as it uses a {@code boundary} Observable to control data
+     *      flow. The inner Observables honor backpressure and buffer everything until the boundary signals the next element.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
diff --git a/src/main/java/rx/internal/operators/OperatorDoOnRequest.java b/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
index 419eb7046c..d45e895b40 100644
--- a/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
+++ b/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
@@ -21,7 +21,8 @@
 import rx.functions.Action1;
 
 /**
- * This operator modifies an {@link rx.Observable} so a given action is invoked when the {@link rx.Observable.Producer} receives a request.
+ * This operator modifies an {@link rx.Observable} so a given action is invoked when the 
+ * {@link rx.Producer} receives a request.
  * 
  * @param <T>
  *            The type of the elements in the {@link rx.Observable} that this operator modifies
diff --git a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java b/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
index c1473c69eb..40b44289b7 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
+++ b/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
@@ -22,7 +22,7 @@
 
 /**
  * If the Observable completes without emitting any items, subscribe to an alternate Observable. Allows for similar
- * functionality to {@link rx.internal.operators.OperatorDefaultIfEmpty} except instead of one item being emitted when
+ * functionality to {@link rx.Observable#defaultIfEmpty(Object)} except instead of one item being emitted when
  * empty, the results of the given Observable will be emitted.
  * @param <T> the value type
  */
diff --git a/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java b/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java
index a6fad8b455..f8a87ffec5 100644
--- a/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java
@@ -29,7 +29,7 @@
  * 
  * @param <M> the event/message type
  */
-interface MessagePassingQueue<M> {
+public interface MessagePassingQueue<M> {
     
     /**
      * Called from a producer thread subject to the restrictions appropriate to the implementation and according to the

From 535fb75901bda3ba26edf5c79b0cbfef7a05580b Mon Sep 17 00:00:00 2001
From: Shixiong Zhu <zsxwing@gmail.com>
Date: Mon, 20 Jun 2016 14:25:22 -0700
Subject: [PATCH 064/263] Use codecov.io for code coverage (#4046)

---
 .travis.yml  |  4 ++++
 README.md    |  2 ++
 build.gradle | 14 ++++++++++++++
 3 files changed, 20 insertions(+)

diff --git a/.travis.yml b/.travis.yml
index 5c90183bda..7a9db57ab4 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,6 +7,10 @@ sudo: false
 # script for build and release via Travis to Bintray
 script: gradle/buildViaTravis.sh
 
+# Code coverage
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
+
 # cache between builds
 cache:
   directories:
diff --git a/README.md b/README.md
index 33336aa681..ab237a8358 100644
--- a/README.md
+++ b/README.md
@@ -18,6 +18,8 @@ Learn more about RxJava on the <a href="https://github.com/ReactiveX/RxJava/wiki
 ## Master Build Status
 
 <a href='https://travis-ci.org/ReactiveX/RxJava/builds'><img src='https://travis-ci.org/ReactiveX/RxJava.svg?branch=1.x'></a>
+[![codecov.io](http://codecov.io/github/ReactiveX/RxJava/coverage.svg?branch=1.x)](http://codecov.io/github/ReactiveX/RxJava?branch=1.x)
+
 
 ## Communication
 
diff --git a/build.gradle b/build.gradle
index 1806a43120..97b585838c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -6,6 +6,7 @@ buildscript {
 description = 'RxJava: Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.'
 
 apply plugin: 'java'
+apply plugin: 'jacoco'
 apply plugin: 'nebula.rxjava-project'
 
 dependencies {
@@ -46,3 +47,16 @@ if (project.hasProperty('release.useLastTag')) {
 test{
      maxHeapSize = "2g"
 }
+
+jacoco {
+    toolVersion = '0.7.7.201606060606' // See http://www.eclemma.org/jacoco/.
+}
+
+jacocoTestReport {
+    reports {
+        xml.enabled = true
+        html.enabled = true
+    }
+}
+
+build.dependsOn jacocoTestReport

From 03bc7a243b2b1afce12db3692371b98d97865fba Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 21 Jun 2016 23:22:41 +0200
Subject: [PATCH 065/263] 1.x: add AsyncCompletableSubscriber that exposes
 unsubscribe() (#4020)

---
 .../observers/AsyncCompletableSubscriber.java | 128 ++++++++++++++++++
 .../AsyncCompletableSubscriberTest.java       |  98 ++++++++++++++
 2 files changed, 226 insertions(+)
 create mode 100644 src/main/java/rx/observers/AsyncCompletableSubscriber.java
 create mode 100644 src/test/java/rx/observers/AsyncCompletableSubscriberTest.java

diff --git a/src/main/java/rx/observers/AsyncCompletableSubscriber.java b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
new file mode 100644
index 0000000000..d61585e4fa
--- /dev/null
+++ b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
@@ -0,0 +1,128 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.observers;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import rx.Completable.CompletableSubscriber;
+import rx.Subscription;
+import rx.annotations.Experimental;
+import rx.internal.util.RxJavaPluginUtils;
+
+/**
+ * An abstract base class for CompletableSubscriber implementations that want to expose an unsubscription
+ * capability.
+ * <p>
+ * Calling {@link #unsubscribe()} and {@link #isUnsubscribed()} is threadsafe and can happen at any time, even
+ * before or during an active {@link rx.Completable#subscribe(CompletableSubscriber)} call.
+ * <p>
+ * Override the {@link #onStart()} method to execute custom logic on the very first successful onSubscribe call.
+ * <p>
+ * If one wants to remain consistent regarding {@link #isUnsubscribed()} and being terminated, 
+ * the {@link #clear()} method should be called from the implementing onError and onCompleted methods.
+ * <p>
+ * <pre><code>
+ * public final class MyCompletableSubscriber extends AsyncCompletableSubscriber {
+ *     &#64;Override
+ *     public void onStart() {
+ *         System.out.println("Started!");
+ *     }
+ *     
+ *     &#64;Override
+ *     public void onCompleted() {
+ *         System.out.println("Completed!");
+ *         clear();
+ *     }
+ *     
+ *     &#64;Override
+ *     public void onError(Throwable e) {
+ *         e.printStackTrace();
+ *         clear();
+ *     }
+ * }
+ * </code></pre>
+ * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ */
+@Experimental
+public abstract class AsyncCompletableSubscriber implements CompletableSubscriber, Subscription {
+
+    /** 
+     * Holds onto a deferred subscription and allows asynchronous cancellation before the call
+     * to onSubscribe() by the upstream. 
+     */
+    private final AtomicReference<Subscription> upstream = new AtomicReference<Subscription>();
+    
+    @Override
+    public final void onSubscribe(Subscription d) {
+        if (!upstream.compareAndSet(null, d)) {
+            d.unsubscribe();
+            if (upstream.get() != UNSUBSCRIBED) {
+                RxJavaPluginUtils.handleException(new IllegalStateException("Subscription already set!"));
+            }
+        } else {
+            onStart();
+        }
+    }
+    
+    /**
+     * Called before the first onSubscribe() call succeeds.
+     */
+    protected void onStart() {
+    }
+    
+    @Override
+    public final boolean isUnsubscribed() {
+        return upstream.get() == UNSUBSCRIBED;
+    }
+    
+    /**
+     * Call to clear the upstream's subscription without unsubscribing it.
+     */
+    protected final void clear() {
+        upstream.set(UNSUBSCRIBED);
+    }
+    
+    @Override
+    public final void unsubscribe() {
+        Subscription current = upstream.get();
+        if (current != UNSUBSCRIBED) {
+            current = upstream.getAndSet(UNSUBSCRIBED);
+            if (current != null && current != UNSUBSCRIBED) {
+                current.unsubscribe();
+            }
+        }
+        
+    }
+    
+    /**
+     * Indicates the unsubscribed state.
+     */
+    static final Unsubscribed UNSUBSCRIBED = new Unsubscribed();
+    
+    static final class Unsubscribed implements Subscription {
+
+        @Override
+        public void unsubscribe() {
+            // deliberately no op
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return true;
+        }
+        
+    }
+}
diff --git a/src/test/java/rx/observers/AsyncCompletableSubscriberTest.java b/src/test/java/rx/observers/AsyncCompletableSubscriberTest.java
new file mode 100644
index 0000000000..7ac34f1628
--- /dev/null
+++ b/src/test/java/rx/observers/AsyncCompletableSubscriberTest.java
@@ -0,0 +1,98 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.observers;
+
+import java.util.*;
+
+import org.junit.*;
+
+import rx.Completable;
+import rx.Observable;
+import rx.exceptions.TestException;
+
+public class AsyncCompletableSubscriberTest {
+
+    static final class TestCS extends AsyncCompletableSubscriber {
+        int started;
+        
+        int completions;
+        
+        final List<Throwable> errors = new ArrayList<Throwable>();
+        
+        @Override
+        protected void onStart() {
+            started++;
+        }
+        
+        @Override
+        public void onCompleted() {
+            completions++;
+            clear();
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            errors.add(e);
+            clear();
+        }
+    }
+    
+    @Test
+    public void normal() {
+        TestCS ts = new TestCS();
+        
+        Assert.assertFalse(ts.isUnsubscribed());
+        
+        Completable.complete().subscribe(ts);
+        
+        Assert.assertEquals(1, ts.started);
+        Assert.assertEquals(1, ts.completions);
+        Assert.assertEquals(ts.errors.toString(), 0, ts.errors.size());
+        Assert.assertTrue(ts.isUnsubscribed());
+    }
+
+    @Test
+    public void error() {
+        TestCS ts = new TestCS();
+        
+        Assert.assertFalse(ts.isUnsubscribed());
+        
+        Completable.error(new TestException("Forced failure")).subscribe(ts);
+        
+        Assert.assertEquals(1, ts.started);
+        Assert.assertEquals(0, ts.completions);
+        Assert.assertEquals(ts.errors.toString(), 1, ts.errors.size());
+        Assert.assertTrue(ts.errors.get(0).toString(), ts.errors.get(0) instanceof TestException);
+        Assert.assertEquals("Forced failure", ts.errors.get(0).getMessage());
+        Assert.assertTrue(ts.isUnsubscribed());
+    }
+
+    
+    @Test
+    public void unsubscribed() {
+        TestCS ts = new TestCS();
+        ts.unsubscribe();
+        
+        Assert.assertTrue(ts.isUnsubscribed());
+        
+        Observable.range(1, 10).toCompletable().subscribe(ts);
+        
+        Assert.assertEquals(0, ts.started);
+        Assert.assertEquals(0, ts.completions);
+        Assert.assertEquals(ts.errors.toString(), 0, ts.errors.size());
+        Assert.assertTrue(ts.isUnsubscribed());
+    }
+}

From 519c38b3d6a8bf68cc361011a226e4a0dfc97fb3 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 22 Jun 2016 09:43:40 +0200
Subject: [PATCH 066/263] 1.x: fix ReplaySubject anomaly around caughtUp by
 disabling that opt. (#4051)

---
 src/main/java/rx/subjects/ReplaySubject.java  |  99 +++++++--------
 .../ReplaySubjectBoundedConcurrencyTest.java  | 113 +++++-------------
 .../ReplaySubjectConcurrencyTest.java         |  31 ++++-
 3 files changed, 99 insertions(+), 144 deletions(-)

diff --git a/src/main/java/rx/subjects/ReplaySubject.java b/src/main/java/rx/subjects/ReplaySubject.java
index d6d9351a8b..a842baedbf 100644
--- a/src/main/java/rx/subjects/ReplaySubject.java
+++ b/src/main/java/rx/subjects/ReplaySubject.java
@@ -26,6 +26,7 @@
 import rx.exceptions.Exceptions;
 import rx.internal.operators.BackpressureUtils;
 import rx.internal.util.RxJavaPluginUtils;
+import rx.schedulers.Schedulers;
 
 /**
  * Subject that buffers all items it observes and replays them to any {@link Observer} that subscribes.
@@ -110,6 +111,24 @@ public static <T> ReplaySubject<T> create(int capacity) {
         ReplayState<T> state = new ReplayState<T>(buffer);
         return new ReplaySubject<T>(state);
     }
+    /**
+     * Creates an unbounded replay subject with the time-bounded-implementation for testing purposes.
+     * <p>
+     * This variant behaves like the regular unbounded {@code ReplaySubject} created via {@link #create()} but
+     * uses the structures of the bounded-implementation. This is by no means intended for the replacement of
+     * the original, array-backed and unbounded {@code ReplaySubject} due to the additional overhead of the
+     * linked-list based internal buffer. The sole purpose is to allow testing and reasoning about the behavior
+     * of the bounded implementations without the interference of the eviction policies.
+     *
+     * @param <T>
+     *          the type of items observed and emitted by the Subject
+     * @return the created subject
+     */
+    /* public */ static <T> ReplaySubject<T> createUnboundedTime() {
+        ReplayBuffer<T> buffer = new ReplaySizeAndTimeBoundBuffer<T>(Integer.MAX_VALUE, Long.MAX_VALUE, Schedulers.immediate());
+        ReplayState<T> state = new ReplayState<T>(buffer);
+        return new ReplaySubject<T>(state);
+    }
     /**
      * Creates a size-bounded replay subject.
      * <p>
@@ -431,14 +450,7 @@ public void onNext(T t) {
             
             b.next(t);
             for (ReplayProducer<T> rp : get()) {
-                if (rp.caughtUp) {
-                    rp.actual.onNext(t);
-                } else {
-                    if (b.drain(rp)) {
-                        rp.caughtUp = true;
-                        rp.node = null;
-                    }
-                }
+                b.drain(rp);
             }
         }
 
@@ -451,14 +463,7 @@ public void onError(Throwable e) {
             List<Throwable> errors = null;
             for (ReplayProducer<T> rp : getAndSet(TERMINATED)) {
                 try {
-                    if (rp.caughtUp) {
-                        rp.actual.onError(e);
-                    } else {
-                        if (b.drain(rp)) {
-                            rp.caughtUp = true;
-                            rp.node = null;
-                        }
-                    }
+                    b.drain(rp);
                 } catch (Throwable ex) {
                     if (errors == null) {
                         errors = new ArrayList<Throwable>();
@@ -477,14 +482,7 @@ public void onCompleted() {
             
             b.complete();
             for (ReplayProducer<T> rp : getAndSet(TERMINATED)) {
-                if (rp.caughtUp) {
-                    rp.actual.onCompleted();
-                } else {
-                    if (b.drain(rp)) {
-                        rp.caughtUp = true;
-                        rp.node = null;
-                    }
-                }
+                b.drain(rp);
             }
         }
         
@@ -508,7 +506,7 @@ interface ReplayBuffer<T> {
         
         void complete();
         
-        boolean drain(ReplayProducer<T> rp);
+        void drain(ReplayProducer<T> rp);
         
         boolean isComplete();
         
@@ -585,9 +583,9 @@ public void complete() {
         }
 
         @Override
-        public boolean drain(ReplayProducer<T> rp) {
+        public void drain(ReplayProducer<T> rp) {
             if (rp.getAndIncrement() != 0) {
-                return false;
+                return;
             }
             
             int missed = 1;
@@ -610,7 +608,7 @@ public boolean drain(ReplayProducer<T> rp) {
                 while (e != r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
-                        return false;
+                        return;
                     }
                     
                     boolean d = done;
@@ -624,7 +622,7 @@ public boolean drain(ReplayProducer<T> rp) {
                         } else {
                             a.onCompleted();
                         }
-                        return false;
+                        return;
                     }
                     
                     if (empty) {
@@ -649,7 +647,7 @@ public boolean drain(ReplayProducer<T> rp) {
                 if (e == r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
-                        return false;
+                        return;
                     }
                     
                     boolean d = done;
@@ -663,7 +661,7 @@ public boolean drain(ReplayProducer<T> rp) {
                         } else {
                             a.onCompleted();
                         }
-                        return false;
+                        return;
                     }
                 }
                 
@@ -679,7 +677,7 @@ public boolean drain(ReplayProducer<T> rp) {
                 
                 missed = rp.addAndGet(-missed);
                 if (missed == 0) {
-                    return r == Long.MAX_VALUE;
+                    return;
                 }
             }
         }
@@ -799,9 +797,9 @@ public void complete() {
         }
 
         @Override
-        public boolean drain(ReplayProducer<T> rp) {
+        public void drain(ReplayProducer<T> rp) {
             if (rp.getAndIncrement() != 0) {
-                return false;
+                return;
             }
             
             final Subscriber<? super T> a = rp.actual;
@@ -822,7 +820,7 @@ public boolean drain(ReplayProducer<T> rp) {
                 while (e != r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
-                        return false;
+                        return;
                     }
                     
                     boolean d = done;
@@ -837,7 +835,7 @@ public boolean drain(ReplayProducer<T> rp) {
                         } else {
                             a.onCompleted();
                         }
-                        return false;
+                        return;
                     }
                     
                     if (empty) {
@@ -853,7 +851,7 @@ public boolean drain(ReplayProducer<T> rp) {
                 if (e == r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
-                        return false;
+                        return;
                     }
                     
                     boolean d = done;
@@ -867,7 +865,7 @@ public boolean drain(ReplayProducer<T> rp) {
                         } else {
                             a.onCompleted();
                         }
-                        return false;
+                        return;
                     }
                 }
                 
@@ -881,7 +879,7 @@ public boolean drain(ReplayProducer<T> rp) {
                 
                 missed = rp.addAndGet(-missed);
                 if (missed == 0) {
-                    return r == Long.MAX_VALUE;
+                    return;
                 }
             }
         }
@@ -1051,9 +1049,9 @@ TimedNode<T> latestHead() {
         }
         
         @Override
-        public boolean drain(ReplayProducer<T> rp) {
+        public void drain(ReplayProducer<T> rp) {
             if (rp.getAndIncrement() != 0) {
-                return false;
+                return;
             }
             
             final Subscriber<? super T> a = rp.actual;
@@ -1074,7 +1072,7 @@ public boolean drain(ReplayProducer<T> rp) {
                 while (e != r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
-                        return false;
+                        return;
                     }
                     
                     boolean d = done;
@@ -1089,7 +1087,7 @@ public boolean drain(ReplayProducer<T> rp) {
                         } else {
                             a.onCompleted();
                         }
-                        return false;
+                        return;
                     }
                     
                     if (empty) {
@@ -1105,7 +1103,7 @@ public boolean drain(ReplayProducer<T> rp) {
                 if (e == r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
-                        return false;
+                        return;
                     }
                     
                     boolean d = done;
@@ -1119,7 +1117,7 @@ public boolean drain(ReplayProducer<T> rp) {
                         } else {
                             a.onCompleted();
                         }
-                        return false;
+                        return;
                     }
                 }
                 
@@ -1133,7 +1131,7 @@ public boolean drain(ReplayProducer<T> rp) {
                 
                 missed = rp.addAndGet(-missed);
                 if (missed == 0) {
-                    return r == Long.MAX_VALUE;
+                    return;
                 }
             }
         }
@@ -1226,14 +1224,6 @@ static final class ReplayProducer<T>
         /** Holds the back-reference to the replay state object. */
         final ReplayState<T> state;
 
-        /** 
-         * Indicates this Subscriber runs unbounded and the <b>source</b>-triggered
-         * buffer.drain() has emitted all available values.
-         * <p>
-         * This field has to be read and written from the source emitter's thread only.
-         */
-        boolean caughtUp;
-        
         /** 
          * Unbounded buffer.drain() uses this field to remember the absolute index of
          * values replayed to this Subscriber.
@@ -1276,6 +1266,5 @@ public void request(long n) {
                 throw new IllegalArgumentException("n >= required but it was " + n);
             }
         }
-        
     }
 }
diff --git a/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java b/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
index 8cbe051594..1c29ee6348 100644
--- a/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
@@ -17,20 +17,16 @@
 
 import static org.junit.Assert.assertEquals;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.BrokenBarrierException;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.CyclicBarrier;
-import java.util.concurrent.TimeUnit;
+import java.util.*;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.*;
 
 import rx.*;
+import rx.Observable;
 import rx.Observable.OnSubscribe;
+import rx.Observer;
 import rx.functions.*;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
@@ -159,86 +155,33 @@ public void onNext(Long args) {
     }
 
     @Test
-    public void testReplaySubjectConcurrentSubscriptions() throws InterruptedException {
-        final ReplaySubject<Long> replay = ReplaySubject.createUnbounded();
-        Thread source = new Thread(new Runnable() {
-
-            @Override
-            public void run() {
-                Observable.create(new OnSubscribe<Long>() {
-
-                    @Override
-                    public void call(Subscriber<? super Long> o) {
-                        System.out.println("********* Start Source Data ***********");
-                        for (long l = 1; l <= 10000; l++) {
-                            o.onNext(l);
-                        }
-                        System.out.println("********* Finished Source Data ***********");
-                        o.onCompleted();
-                    }
-                }).subscribe(replay);
-            }
-        });
-
-        // used to collect results of each thread
-        final List<List<Long>> listOfListsOfValues = Collections.synchronizedList(new ArrayList<List<Long>>());
-        final List<Thread> threads = Collections.synchronizedList(new ArrayList<Thread>());
-
-        for (int i = 1; i <= 200; i++) {
-            final int count = i;
-            if (count == 20) {
-                // start source data after we have some already subscribed
-                // and while others are in process of subscribing
-                source.start();
-            }
-            if (count == 100) {
-                // wait for source to finish then keep adding after it's done
-                source.join();
-            }
-            Thread t = new Thread(new Runnable() {
-
-                @Override
-                public void run() {
-                    List<Long> values = replay.toList().toBlocking().last();
-                    listOfListsOfValues.add(values);
-                    System.out.println("Finished thread: " + count);
-                }
-            });
-            t.start();
-            System.out.println("Started thread: " + i);
-            threads.add(t);
-        }
-
-        // wait for all threads to complete
-        for (Thread t : threads) {
-            t.join();
-        }
-
-        // assert all threads got the same results
-        List<Long> sums = new ArrayList<Long>();
-        for (List<Long> values : listOfListsOfValues) {
-            long v = 0;
-            for (long l : values) {
-                v += l;
-            }
-            sums.add(v);
-        }
-
-        long expected = sums.get(0);
-        boolean success = true;
-        for (long l : sums) {
-            if (l != expected) {
-                success = false;
-                System.out.println("FAILURE => Expected " + expected + " but got: " + l);
-            }
+    public void unboundedReplaySubjectConcurrentSubscriptionsLoop() throws Exception {
+        for (int i = 0; i < 50; i++) {
+            System.out.println(i + " --------------------------------------------------------------- ");
+            unboundedReplaySubjectConcurrentSubscriptions();
         }
+    }
+    
+    @Test
+    public void unboundedReplaySubjectConcurrentSubscriptions() throws InterruptedException {
+        final ReplaySubject<Long> replay = ReplaySubject.createUnbounded();
+        
+        ReplaySubjectConcurrencyTest.concurrencyTest(replay);
+    }
 
-        if (success) {
-            System.out.println("Success! " + sums.size() + " each had the same sum of " + expected);
-        } else {
-            throw new RuntimeException("Concurrency Bug");
+    @Test
+    public void unboundedTimeReplaySubjectConcurrentSubscriptionsLoop() throws Exception {
+        for (int i = 0; i < 50; i++) {
+            System.out.println(i + " --------------------------------------------------------------- ");
+            unboundedTimeReplaySubjectConcurrentSubscriptions();
         }
-
+    }
+    
+    @Test
+    public void unboundedTimeReplaySubjectConcurrentSubscriptions() throws InterruptedException {
+        final ReplaySubject<Long> replay = ReplaySubject.createUnboundedTime();
+        
+        ReplaySubjectConcurrencyTest.concurrencyTest(replay);
     }
 
     /**
diff --git a/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java b/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
index e0744ef1d2..593e96c528 100644
--- a/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
@@ -154,9 +154,22 @@ public void onNext(Long args) {
         slowThread.join();
     }
 
+    @Test
+    public void testReplaySubjectConcurrentSubscriptionsLoop() throws Exception {
+        for (int i = 0; i < 50; i++) {
+            System.out.println(i + " --------------------------------------------------------------- ");
+            testReplaySubjectConcurrentSubscriptions();
+        }
+    }
+    
     @Test
     public void testReplaySubjectConcurrentSubscriptions() throws InterruptedException {
         final ReplaySubject<Long> replay = ReplaySubject.create();
+        
+        concurrencyTest(replay);
+    }
+    
+    public static void concurrencyTest(final ReplaySubject<Long> replay) throws InterruptedException {
         Thread source = new Thread(new Runnable() {
 
             @Override
@@ -210,12 +223,23 @@ public void run() {
             t.join();
         }
 
+        StringBuilder sb = new StringBuilder();
+
         // assert all threads got the same results
         List<Long> sums = new ArrayList<Long>();
         for (List<Long> values : listOfListsOfValues) {
             long v = 0;
-            for (long l : values) {
+            if (values.size() != 10000) {
+                sb.append("A list is longer than expected: " + values.size() + "\n");
+            }
+            int i = 0;
+            for (Long l : values) {
+                if (l == null) {
+                    sb.append("Element at  " + i + " is null\n");
+                    break;
+                }
                 v += l;
+                i++;
             }
             sums.add(v);
         }
@@ -225,16 +249,15 @@ public void run() {
         for (long l : sums) {
             if (l != expected) {
                 success = false;
-                System.out.println("FAILURE => Expected " + expected + " but got: " + l);
+                sb.append("FAILURE => Expected " + expected + " but got: " + l + "\n");
             }
         }
 
         if (success) {
             System.out.println("Success! " + sums.size() + " each had the same sum of " + expected);
         } else {
-            throw new RuntimeException("Concurrency Bug");
+            Assert.fail(sb.toString());
         }
-
     }
 
     /**

From 161dbef61abc57aed43ef1b09737e9dfc8340d3c Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 22 Jun 2016 09:44:08 +0200
Subject: [PATCH 067/263] 1.x: fix timed replay() replaying old data for late
 subscribers (#4023)

---
 .../rx/internal/operators/OperatorReplay.java | 28 ++++++++++-
 .../operators/OperatorReplayTest.java         | 46 +++++++++++++++++--
 2 files changed, 69 insertions(+), 5 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorReplay.java b/src/main/java/rx/internal/operators/OperatorReplay.java
index 7cec48cc25..84338b96f9 100644
--- a/src/main/java/rx/internal/operators/OperatorReplay.java
+++ b/src/main/java/rx/internal/operators/OperatorReplay.java
@@ -1005,6 +1005,16 @@ final void setFirst(Node n) {
             set(n);
         }
         
+        /**
+         * Returns the current head for initializing the replay location
+         * for a new subscriber.
+         * Override it to consider linked but outdated elements.
+         * @return the current head
+         */
+        Node getInitialHead() {
+            return get();
+        }
+        
         @Override
         public final void next(T value) {
             Object o = enterTransform(nl.next(value));
@@ -1049,7 +1059,7 @@ public final void replay(InnerProducer<T> output) {
                 
                 Node node = output.index();
                 if (node == null) {
-                    node = get();
+                    node = getInitialHead();
                     output.index = node;
                     
                     /*
@@ -1143,7 +1153,7 @@ void truncateFinal() {
             
         }
         /* test */ final  void collect(Collection<? super T> output) {
-            Node n = get();
+            Node n = getInitialHead();
             for (;;) {
                 Node next = n.get();
                 if (next != null) {
@@ -1219,6 +1229,20 @@ Object leaveTransform(Object value) {
             return ((Timestamped<?>)value).getValue();
         }
         
+        @Override
+        Node getInitialHead() {
+            long timeLimit = scheduler.now() - maxAgeInMillis;
+            Node prev = get();
+            
+            Node next = prev.get();
+            while (next != null && ((Timestamped<?>)next.value).getTimestampMillis() <= timeLimit) {
+                prev = next;
+                next = next.get();
+            }
+            
+            return prev;
+        }
+        
         @Override
         void truncate() {
             long timeLimit = scheduler.now() - maxAgeInMillis;
diff --git a/src/test/java/rx/internal/operators/OperatorReplayTest.java b/src/test/java/rx/internal/operators/OperatorReplayTest.java
index f8653f10bd..4d7f184951 100644
--- a/src/test/java/rx/internal/operators/OperatorReplayTest.java
+++ b/src/test/java/rx/internal/operators/OperatorReplayTest.java
@@ -193,7 +193,8 @@ public void testWindowedReplay() {
             InOrder inOrder = inOrder(observer1);
 
             co.subscribe(observer1);
-            inOrder.verify(observer1, times(1)).onNext(3);
+            // since onComplete is also delayed, value 3 becomes too old for replay.
+            inOrder.verify(observer1, never()).onNext(3);
 
             inOrder.verify(observer1, times(1)).onCompleted();
             inOrder.verifyNoMoreInteractions();
@@ -479,7 +480,8 @@ public void testWindowedReplayError() {
             InOrder inOrder = inOrder(observer1);
 
             co.subscribe(observer1);
-            inOrder.verify(observer1, times(1)).onNext(3);
+            // since onError is also delayed, value 3 becomes too old for replay.
+            inOrder.verify(observer1, never()).onNext(3);
 
             inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class));
             inOrder.verifyNoMoreInteractions();
@@ -788,10 +790,16 @@ public void testTimedAndSizedTruncation() {
         buf.next(1);
         test.advanceTimeBy(1, TimeUnit.SECONDS);
         buf.next(2);
-        test.advanceTimeBy(1, TimeUnit.SECONDS);
+        // exact 1 second makes value 1 too old
+        test.advanceTimeBy(900, TimeUnit.MILLISECONDS);
         buf.collect(values);
         Assert.assertEquals(Arrays.asList(1, 2), values);
 
+        values.clear();
+        test.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+        buf.collect(values);
+        Assert.assertEquals(Arrays.asList(2), values);
+
         buf.next(3);
         buf.next(4);
         values.clear();
@@ -1257,4 +1265,36 @@ public void testSubscribersComeAndGoAtRequestBoundaries2() {
         ts3.assertValues(2, 3, 4, 5, 6, 7, 8, 9, 10);
         ts3.assertCompleted();
     }
+    
+    @Test
+    public void dontReplayOldValues() {
+        
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        TestScheduler scheduler = new TestScheduler();
+        
+        ConnectableObservable<Integer> co = ps.replay(1, TimeUnit.SECONDS, scheduler);
+        
+        co.subscribe(); // make sure replay runs in unbounded mode
+        
+        co.connect();
+        
+        ps.onNext(1);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        ps.onNext(2);
+
+        scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
+        
+        ps.onNext(3);
+
+        scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        co.subscribe(ts);
+        
+        ts.assertValue(3);
+    }
 }
\ No newline at end of file

From c31dd7f5eb54fb393f52a32a782255a7dec9f024 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 22 Jun 2016 11:05:35 +0200
Subject: [PATCH 068/263] 1.x: coverage improvements, small adjustments (#4060)

---
 build.gradle                                  |   4 +-
 src/main/java/rx/Notification.java            |  29 +-
 src/main/java/rx/Observable.java              |   3 +-
 src/main/java/rx/Scheduler.java               |   3 +-
 .../java/rx/observers/SerializedObserver.java |  43 ++-
 src/test/java/rx/NotificationTest.java        | 257 ++++++++++++++----
 .../java/rx/ObservableConversionTest.java     |   2 +-
 .../java/rx/exceptions/TestException.java     |  10 +
 .../operators/BlockingOperatorLatestTest.java |   2 +-
 .../operators/OperatorSwitchTest.java         |   4 +-
 .../internal/operators/OperatorZipTest.java   |   5 +-
 .../observers/CompletableSubscriberTest.java  | 192 +++++++++++++
 src/test/java/rx/observers/ObserversTest.java | 122 ++++++++-
 .../java/rx/observers/SafeObserverTest.java   |   2 +-
 .../java/rx/observers/SubscribersTest.java    |  24 ++
 .../java/rx/observers/TestSubscriberTest.java |   4 +-
 .../rx/schedulers/AbstractSchedulerTests.java |  71 +++--
 .../rx/schedulers/NewThreadSchedulerTest.java |   2 +-
 .../ReplaySubjectConcurrencyTest.java         |   3 +-
 .../MultipleAssignmentSubscriptionTest.java   |   2 +-
 20 files changed, 648 insertions(+), 136 deletions(-)
 create mode 100644 src/test/java/rx/observers/CompletableSubscriberTest.java

diff --git a/build.gradle b/build.gradle
index 97b585838c..1026fa9031 100644
--- a/build.gradle
+++ b/build.gradle
@@ -10,8 +10,8 @@ apply plugin: 'jacoco'
 apply plugin: 'nebula.rxjava-project'
 
 dependencies {
-    testCompile 'junit:junit-dep:4.10'
-    testCompile 'org.mockito:mockito-core:1.8.5'
+    testCompile 'junit:junit:4.12'
+    testCompile 'org.mockito:mockito-core:1.10.19'
 
     perfCompile 'org.openjdk.jmh:jmh-core:1.11.3'
     perfCompile 'org.openjdk.jmh:jmh-generator-annprocess:1.11.3'
diff --git a/src/main/java/rx/Notification.java b/src/main/java/rx/Notification.java
index e7099007c5..71fb95c745 100644
--- a/src/main/java/rx/Notification.java
+++ b/src/main/java/rx/Notification.java
@@ -158,15 +158,24 @@ public boolean isOnNext() {
      * @param observer the target observer to call onXXX methods on based on the kind of this Notification instance
      */
     public void accept(Observer<? super T> observer) {
-        if (isOnNext()) {
+        switch (kind) {
+        case OnNext:
             observer.onNext(getValue());
-        } else if (isOnCompleted()) {
-            observer.onCompleted();
-        } else if (isOnError()) {
+            break;
+        case OnError:
             observer.onError(getThrowable());
+            break;
+        case OnCompleted:
+            observer.onCompleted();
+            break;
+        default:
+            throw new AssertionError("Uncovered case: " + kind);
         }
     }
 
+    /**
+     * Specifies the kind of the notification: an element, an error or a completion notification.
+     */
     public enum Kind {
         OnNext, OnError, OnCompleted
     }
@@ -211,19 +220,11 @@ public boolean equals(Object obj) {
             return false;
         }
 
-        if (hasValue() && !getValue().equals(notification.getValue())) {
-            return false;
-        }
-
-        if (hasThrowable() && !getThrowable().equals(notification.getThrowable())) {
-            return false;
-        }
-
-        if (!hasValue() && !hasThrowable() && notification.hasValue()) {
+        if (!(value == notification.value || (value != null && value.equals(notification.value)))) {
             return false;
         }
 
-        if (!hasValue() && !hasThrowable() && notification.hasThrowable()) {
+        if (!(throwable == notification.throwable || (throwable != null && throwable.equals(notification.throwable)))) {
             return false;
         }
 
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 89624f40fd..53d14c4cfd 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -3280,7 +3280,8 @@ public static <R> Observable<R> zip(Iterable<? extends Observable<?>> ws, FuncN<
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     *
+     * 
+     * @param <R> the result type
      * @param ws
      *            an array of source Observables
      * @param zipFunction
diff --git a/src/main/java/rx/Scheduler.java b/src/main/java/rx/Scheduler.java
index 921528c875..8437396e56 100644
--- a/src/main/java/rx/Scheduler.java
+++ b/src/main/java/rx/Scheduler.java
@@ -130,8 +130,9 @@ public Subscription schedulePeriodically(final Action0 action, long initialDelay
                 long startInNanos = firstStartInNanos;
                 @Override
                 public void call() {
+                    action.call();
+
                     if (!mas.isUnsubscribed()) {
-                        action.call();
                         
                         long nextTick;
                         
diff --git a/src/main/java/rx/observers/SerializedObserver.java b/src/main/java/rx/observers/SerializedObserver.java
index ffb3670aac..1629efe85f 100644
--- a/src/main/java/rx/observers/SerializedObserver.java
+++ b/src/main/java/rx/observers/SerializedObserver.java
@@ -43,9 +43,6 @@ public class SerializedObserver<T> implements Observer<T> {
     private FastList queue;
     private final NotificationLite<T> nl = NotificationLite.instance();
 
-    /** Number of iterations without additional safepoint poll in the drain loop. */
-    private static final int MAX_DRAIN_ITERATION = 1024;
-
     static final class FastList {
         Object[] array;
         int size;
@@ -99,31 +96,29 @@ public void onNext(T t) {
             return;
         }
         for (;;) {
-            for (int i = 0; i < MAX_DRAIN_ITERATION; i++) {
-                FastList list;
-                synchronized (this) {
-                    list = queue;
-                    if (list == null) {
-                        emitting = false;
-                        return;
-                    }
-                    queue = null;
+            FastList list;
+            synchronized (this) {
+                list = queue;
+                if (list == null) {
+                    emitting = false;
+                    return;
                 }
-                for (Object o : list.array) {
-                    if (o == null) {
-                        break;
-                    }
-                    try {
-                        if (nl.accept(actual, o)) {
-                            terminated = true;
-                            return;
-                        }
-                    } catch (Throwable e) {
+                queue = null;
+            }
+            for (Object o : list.array) {
+                if (o == null) {
+                    break;
+                }
+                try {
+                    if (nl.accept(actual, o)) {
                         terminated = true;
-                        Exceptions.throwIfFatal(e);
-                        actual.onError(OnErrorThrowable.addValueAsLastCause(e, t));
                         return;
                     }
+                } catch (Throwable e) {
+                    terminated = true;
+                    Exceptions.throwIfFatal(e);
+                    actual.onError(OnErrorThrowable.addValueAsLastCause(e, t));
+                    return;
                 }
             }
         }
diff --git a/src/test/java/rx/NotificationTest.java b/src/test/java/rx/NotificationTest.java
index 7de7749940..bd6e224ca9 100644
--- a/src/test/java/rx/NotificationTest.java
+++ b/src/test/java/rx/NotificationTest.java
@@ -16,65 +16,204 @@
 
 package rx;
 
-import org.junit.Assert;
-import org.junit.Test;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.*;
+
+import java.util.*;
+
+import org.junit.*;
+
+import rx.exceptions.TestException;
 
 public class NotificationTest {
-	
-	@Test
-	public void testOnNextIntegerNotificationDoesNotEqualNullNotification(){
-		final Notification<Integer> integerNotification = Notification.createOnNext(1);
-		final Notification<Integer> nullNotification = Notification.createOnNext(null);
-		Assert.assertFalse(integerNotification.equals(nullNotification));
-	}
-	
-	@Test
-	public void testOnNextNullNotificationDoesNotEqualIntegerNotification(){
-		final Notification<Integer> integerNotification = Notification.createOnNext(1);
-		final Notification<Integer> nullNotification = Notification.createOnNext(null);
-		Assert.assertFalse(nullNotification.equals(integerNotification));
-	}
-	
-	@Test
-	public void testOnNextIntegerNotificationsWhenEqual(){
-		final Notification<Integer> integerNotification = Notification.createOnNext(1);
-		final Notification<Integer> integerNotification2 = Notification.createOnNext(1);
-		Assert.assertTrue(integerNotification.equals(integerNotification2));
-	}
-	
-	@Test
-	public void testOnNextIntegerNotificationsWhenNotEqual(){
-		final Notification<Integer> integerNotification = Notification.createOnNext(1);
-		final Notification<Integer> integerNotification2 = Notification.createOnNext(2);
-		Assert.assertFalse(integerNotification.equals(integerNotification2));
-	}
-	
-	@Test
-	public void testOnErrorIntegerNotificationDoesNotEqualNullNotification(){
-		final Notification<Integer> integerNotification = Notification.createOnError(new Exception());
-		final Notification<Integer> nullNotification = Notification.createOnError(null);
-		Assert.assertFalse(integerNotification.equals(nullNotification));
-	}
-	
-	@Test
-	public void testOnErrorNullNotificationDoesNotEqualIntegerNotification(){
-		final Notification<Integer> integerNotification = Notification.createOnError(new Exception());
-		final Notification<Integer> nullNotification = Notification.createOnError(null);
-		Assert.assertFalse(nullNotification.equals(integerNotification));
-	}
-
-	@Test
-	public void testOnErrorIntegerNotificationsWhenEqual(){
-		final Exception exception = new Exception();
-		final Notification<Integer> onErrorNotification = Notification.createOnError(exception);
-		final Notification<Integer> onErrorNotification2 = Notification.createOnError(exception);
-		Assert.assertTrue(onErrorNotification.equals(onErrorNotification2));
-	}
-	
-	@Test
-	public void testOnErrorIntegerNotificationWhenNotEqual(){
-		final Notification<Integer> onErrorNotification = Notification.createOnError(new Exception());
-		final Notification<Integer> onErrorNotification2 = Notification.createOnError(new Exception());
-		Assert.assertFalse(onErrorNotification.equals(onErrorNotification2));
-	}
+
+    @Test
+    public void testOnNextIntegerNotificationDoesNotEqualNullNotification(){
+        final Notification<Integer> integerNotification = Notification.createOnNext(1);
+        final Notification<Integer> nullNotification = Notification.createOnNext(null);
+        Assert.assertFalse(integerNotification.equals(nullNotification));
+    }
+
+    @Test
+    public void testOnNextNullNotificationDoesNotEqualIntegerNotification(){
+        final Notification<Integer> integerNotification = Notification.createOnNext(1);
+        final Notification<Integer> nullNotification = Notification.createOnNext(null);
+        Assert.assertFalse(nullNotification.equals(integerNotification));
+    }
+
+    @Test
+    public void testOnNextIntegerNotificationsWhenEqual(){
+        final Notification<Integer> integerNotification = Notification.createOnNext(1);
+        final Notification<Integer> integerNotification2 = Notification.createOnNext(1);
+        Assert.assertTrue(integerNotification.equals(integerNotification2));
+    }
+
+    @Test
+    public void testOnNextIntegerNotificationsWhenNotEqual(){
+        final Notification<Integer> integerNotification = Notification.createOnNext(1);
+        final Notification<Integer> integerNotification2 = Notification.createOnNext(2);
+        Assert.assertFalse(integerNotification.equals(integerNotification2));
+    }
+
+    @Test
+    public void testOnErrorIntegerNotificationDoesNotEqualNullNotification(){
+        final Notification<Integer> integerNotification = Notification.createOnError(new Exception());
+        final Notification<Integer> nullNotification = Notification.createOnError(null);
+        Assert.assertFalse(integerNotification.equals(nullNotification));
+    }
+
+    @Test
+    public void testOnErrorNullNotificationDoesNotEqualIntegerNotification(){
+        final Notification<Integer> integerNotification = Notification.createOnError(new Exception());
+        final Notification<Integer> nullNotification = Notification.createOnError(null);
+        Assert.assertFalse(nullNotification.equals(integerNotification));
+    }
+
+    @Test
+    public void testOnErrorIntegerNotificationsWhenEqual(){
+        final Exception exception = new Exception();
+        final Notification<Integer> onErrorNotification = Notification.createOnError(exception);
+        final Notification<Integer> onErrorNotification2 = Notification.createOnError(exception);
+        Assert.assertTrue(onErrorNotification.equals(onErrorNotification2));
+    }
+
+    @Test
+    public void testOnErrorIntegerNotificationWhenNotEqual(){
+        final Notification<Integer> onErrorNotification = Notification.createOnError(new Exception());
+        final Notification<Integer> onErrorNotification2 = Notification.createOnError(new Exception());
+        Assert.assertFalse(onErrorNotification.equals(onErrorNotification2));
+    }
+
+    @Test
+    public void createWithClass() {
+        Notification<Integer> n = Notification.createOnCompleted(Integer.class);
+        Assert.assertTrue(n.isOnCompleted());
+        Assert.assertFalse(n.hasThrowable());
+        Assert.assertFalse(n.hasValue());
+    }
+
+    @Test
+    public void accept() {
+        @SuppressWarnings("unchecked")
+        Observer<Object> o = mock(Observer.class);
+
+        Notification.createOnNext(1).accept(o);
+        Notification.createOnError(new TestException()).accept(o);
+        Notification.createOnCompleted().accept(o);
+
+        verify(o).onNext(1);
+        verify(o).onError(any(TestException.class));
+        verify(o).onCompleted();
+    }
+
+    /** Strip the &#64;NNNNNN from the string. */
+    static String stripAt(String s) {
+        int index = s.indexOf('@');
+        if (index >= 0) {
+            int j = s.indexOf(' ', index);
+            if (j >= 0) {
+                return s.substring(0, index) + s.substring(j);
+            }
+            return s.substring(0, index);
+        }
+        return s;
+    }
+
+    @Test
+    public void toStringVariants() {
+        Assert.assertEquals("[rx.Notification OnNext 1]", stripAt(Notification.createOnNext(1).toString()));
+        Assert.assertEquals("[rx.Notification OnError Forced failure]", stripAt(Notification.createOnError(new TestException("Forced failure")).toString()));
+        Assert.assertEquals("[rx.Notification OnCompleted]", stripAt(Notification.createOnCompleted().toString()));
+    }
+
+    @Test
+    public void hashCodeWorks() {
+        Notification<Integer> n1 = Notification.createOnNext(1);
+        Notification<Integer> n1a = Notification.createOnNext(1);
+        Notification<Integer> n2 = Notification.createOnNext(2);
+        Notification<Integer> e1 = Notification.createOnError(new TestException());
+        Notification<Integer> c1 = Notification.createOnCompleted();
+
+        Assert.assertEquals(n1.hashCode(), n1a.hashCode());
+
+        Set<Notification<Integer>> set = new HashSet<Notification<Integer>>();
+
+        set.add(n1);
+        set.add(n2);
+        set.add(e1);
+        set.add(c1);
+
+        Assert.assertTrue(set.contains(n1));
+        Assert.assertTrue(set.contains(n1a));
+        Assert.assertTrue(set.contains(n2));
+        Assert.assertTrue(set.contains(e1));
+        Assert.assertTrue(set.contains(c1));
+    }
+
+    @Test
+    public void equalsWorks() {
+        Notification<Integer> z1 = Notification.createOnNext(null);
+        Notification<Integer> z1a = Notification.createOnNext(null);
+
+        
+        Notification<Integer> n1 = Notification.createOnNext(1);
+        Notification<Integer> n1a = Notification.createOnNext(new Integer(1)); // make unique reference
+        Notification<Integer> n2 = Notification.createOnNext(2);
+        Notification<Integer> e1 = Notification.createOnError(new TestException());
+        Notification<Integer> e2 = Notification.createOnError(new TestException());
+        Notification<Integer> c1 = Notification.createOnCompleted();
+        Notification<Integer> c2 = Notification.createOnCompleted();
+
+        Assert.assertEquals(n1, n1a);
+        Assert.assertNotEquals(n1, n2);
+        Assert.assertNotEquals(n2, n1);
+
+        Assert.assertNotEquals(n1, e1);
+        Assert.assertNotEquals(e1, n1);
+        Assert.assertNotEquals(e1, c1);
+        Assert.assertNotEquals(n1, c1);
+        Assert.assertNotEquals(c1, n1);
+        Assert.assertNotEquals(c1, e1);
+
+        Assert.assertEquals(e1, e1);
+        Assert.assertEquals(e1, e2);
+
+        Assert.assertEquals(c1, c2);
+
+        Assert.assertFalse(n1.equals(null));
+        Assert.assertFalse(n1.equals(1));
+        
+        Assert.assertEquals(z1a, z1);
+        Assert.assertEquals(z1, z1a);
+    }
+    
+    @Test
+    public void contentChecks() {
+        Notification<Integer> z1 = Notification.createOnNext(null);
+        Notification<Integer> n1 = Notification.createOnNext(1);
+        Notification<Integer> e1 = Notification.createOnError(new TestException());
+        Notification<Integer> e2 = Notification.createOnError(null);
+        Notification<Integer> c1 = Notification.createOnCompleted();
+
+        Assert.assertFalse(z1.hasValue());
+        Assert.assertFalse(z1.hasThrowable());
+        Assert.assertFalse(z1.isOnCompleted());
+        
+        Assert.assertTrue(n1.hasValue());
+        Assert.assertFalse(n1.hasThrowable());
+        Assert.assertFalse(n1.isOnCompleted());
+        
+        Assert.assertFalse(e1.hasValue());
+        Assert.assertTrue(e1.hasThrowable());
+        Assert.assertFalse(e1.isOnCompleted());
+
+        Assert.assertFalse(e2.hasValue());
+        Assert.assertFalse(e2.hasThrowable());
+        Assert.assertFalse(e2.isOnCompleted());
+
+        Assert.assertFalse(c1.hasValue());
+        Assert.assertFalse(c1.hasThrowable());
+        Assert.assertTrue(c1.isOnCompleted());
+
+    }
 }
diff --git a/src/test/java/rx/ObservableConversionTest.java b/src/test/java/rx/ObservableConversionTest.java
index 9e2f6e7cdd..56f3ee2cd5 100644
--- a/src/test/java/rx/ObservableConversionTest.java
+++ b/src/test/java/rx/ObservableConversionTest.java
@@ -22,7 +22,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
-import static junit.framework.Assert.*;
+import static org.junit.Assert.*;
 
 import org.junit.Test;
 
diff --git a/src/test/java/rx/exceptions/TestException.java b/src/test/java/rx/exceptions/TestException.java
index 16422b7f25..34bcd8d68b 100644
--- a/src/test/java/rx/exceptions/TestException.java
+++ b/src/test/java/rx/exceptions/TestException.java
@@ -33,4 +33,14 @@ public TestException() {
     public TestException(String message) {
         super(message);
     }
+    
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        String thisMessage = getMessage();
+        String otherMessage = ((TestException)o).getMessage();
+        return thisMessage == otherMessage || (thisMessage != null && thisMessage.equals(otherMessage));
+    }
 }
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java b/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
index 35410714f8..2c586019ed 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
@@ -19,7 +19,7 @@
 import java.util.NoSuchElementException;
 import java.util.concurrent.TimeUnit;
 
-import junit.framework.Assert;
+import org.junit.Assert;
 
 import org.junit.Test;
 
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchTest.java b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
index ae85d48864..d11c44ec2c 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
@@ -868,10 +868,10 @@ public void call(Throwable e) {
                             });
                 }
             })
-            .timeout(20, TimeUnit.SECONDS)
+            .timeout(30, TimeUnit.SECONDS)
             .subscribe(ts);
             
-            ts.awaitTerminalEvent(45, TimeUnit.SECONDS);
+            ts.awaitTerminalEvent(60, TimeUnit.SECONDS);
             if (!q.isEmpty()) {
                 throw new AssertionError("Dropped exceptions", new CompositeException(q));
             }
diff --git a/src/test/java/rx/internal/operators/OperatorZipTest.java b/src/test/java/rx/internal/operators/OperatorZipTest.java
index 5ba0adaa45..7dd255b1f9 100644
--- a/src/test/java/rx/internal/operators/OperatorZipTest.java
+++ b/src/test/java/rx/internal/operators/OperatorZipTest.java
@@ -36,7 +36,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import junit.framework.Assert;
+import org.junit.Assert;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -1000,6 +1000,7 @@ public Object call(final Object... args) {
 
     @Test
     public void testZipEmptyArray() {
+        @SuppressWarnings("unchecked")
         Observable<Integer>[] ws = new Observable[0];
         Observable<Integer> o = Observable.zip(ws, new FuncN<Integer>() {
             @Override
@@ -1018,6 +1019,7 @@ public Integer call(Object... args) {
     @Test
     public void testZipArraySingleItem() {
         final Integer expected = 0;
+        @SuppressWarnings("unchecked")
         Observable<Integer>[] ws = new Observable[]{ Observable.just(expected) };
 
         Observable<Integer> o = Observable.zip(ws, new FuncN<Integer>() {
@@ -1038,6 +1040,7 @@ public Integer call(Object... args) {
     public void testZipBigArray() {
         final int size = 20;
         Integer expected = 0;
+        @SuppressWarnings("unchecked")
         Observable<Integer>[] ws = new Observable[size];
 
         for (int i = 0, wsLength = ws.length; i < wsLength; i++) {
diff --git a/src/test/java/rx/observers/CompletableSubscriberTest.java b/src/test/java/rx/observers/CompletableSubscriberTest.java
new file mode 100644
index 0000000000..be598dc04c
--- /dev/null
+++ b/src/test/java/rx/observers/CompletableSubscriberTest.java
@@ -0,0 +1,192 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.observers;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.*;
+
+import rx.Completable.CompletableSubscriber;
+import rx.exceptions.*;
+import rx.Subscription;
+import rx.subscriptions.Subscriptions;
+
+public class CompletableSubscriberTest {
+
+    @Test
+    public void childOnSubscribeThrows() {
+        
+        final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
+        
+        SafeCompletableSubscriber safe = new SafeCompletableSubscriber(new CompletableSubscriber() {
+            
+            @Override
+            public void onSubscribe(Subscription d) {
+                throw new TestException();
+            }
+            
+            @Override
+            public void onError(Throwable e) {
+                error.set(e);
+                
+            }
+            
+            @Override
+            public void onCompleted() {
+                
+            }
+        });
+        
+        safe.onSubscribe(Subscriptions.empty());
+        
+        Assert.assertTrue("" + error.get(), error.get() instanceof TestException);
+        
+        Assert.assertTrue(safe.isUnsubscribed());
+    }
+    
+    @Test
+    public void unsubscribeComposes() {
+        
+        SafeCompletableSubscriber safe = new SafeCompletableSubscriber(new CompletableSubscriber() {
+            
+            @Override
+            public void onSubscribe(Subscription d) {
+            }
+            
+            @Override
+            public void onError(Throwable e) {
+            }
+            
+            @Override
+            public void onCompleted() {
+                
+            }
+        });
+        
+        Subscription empty = Subscriptions.empty();
+        safe.onSubscribe(empty);
+        
+        Assert.assertFalse(empty.isUnsubscribed());
+        Assert.assertFalse(safe.isUnsubscribed());
+        
+        safe.unsubscribe();
+        
+        Assert.assertTrue(empty.isUnsubscribed());
+        Assert.assertTrue(safe.isUnsubscribed());
+    }
+    
+    @Test
+    public void childOnErrorThrows() {
+        
+        SafeCompletableSubscriber safe = new SafeCompletableSubscriber(new CompletableSubscriber() {
+            
+            @Override
+            public void onSubscribe(Subscription d) {
+            }
+            
+            @Override
+            public void onError(Throwable e) {
+                throw new TestException();
+            }
+            
+            @Override
+            public void onCompleted() {
+                
+            }
+        });
+        
+        safe.onSubscribe(Subscriptions.empty());
+        
+        try {
+            safe.onError(new IOException());
+            Assert.fail("Didn't throw a fatal exception");
+        } catch (OnErrorFailedException ex) {
+            CompositeException ce = (CompositeException)ex.getCause();
+            
+            List<Throwable> list = ce.getExceptions();
+            Assert.assertEquals(2, list.size());
+            
+            Assert.assertTrue("" + list.get(0), list.get(0) instanceof IOException);
+            Assert.assertTrue("" + list.get(1), list.get(1) instanceof TestException);
+        }
+    }
+    
+    @Test
+    public void preventsCompleteError() {
+
+        final boolean[] calls = { false, false };
+        
+        SafeCompletableSubscriber safe = new SafeCompletableSubscriber(new CompletableSubscriber() {
+            
+            @Override
+            public void onSubscribe(Subscription d) {
+            }
+            
+            @Override
+            public void onError(Throwable e) {
+                calls[0] = true;
+            }
+            
+            @Override
+            public void onCompleted() {
+                calls[1] = true;
+            }
+        });
+        
+        safe.onSubscribe(Subscriptions.empty());
+
+        safe.onCompleted();
+        safe.onError(new TestException());
+        
+        Assert.assertTrue(safe.isUnsubscribed());
+        Assert.assertFalse(calls[0]);
+        Assert.assertTrue(calls[1]);
+    }
+    
+    @Test
+    public void preventsErrorComplete() {
+
+        final boolean[] calls = { false, false };
+        
+        SafeCompletableSubscriber safe = new SafeCompletableSubscriber(new CompletableSubscriber() {
+            
+            @Override
+            public void onSubscribe(Subscription d) {
+            }
+            
+            @Override
+            public void onError(Throwable e) {
+                calls[0] = true;
+            }
+            
+            @Override
+            public void onCompleted() {
+                calls[1] = true;
+            }
+        });
+        
+        safe.onSubscribe(Subscriptions.empty());
+
+        safe.onError(new TestException());
+        safe.onCompleted();
+        
+        Assert.assertTrue(safe.isUnsubscribed());
+        Assert.assertTrue(calls[0]);
+        Assert.assertFalse(calls[1]);
+    }
+}
diff --git a/src/test/java/rx/observers/ObserversTest.java b/src/test/java/rx/observers/ObserversTest.java
index df8b3aae99..4507306f51 100644
--- a/src/test/java/rx/observers/ObserversTest.java
+++ b/src/test/java/rx/observers/ObserversTest.java
@@ -18,11 +18,15 @@
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
+import java.io.IOException;
 import java.lang.reflect.*;
+import java.util.Queue;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
-import org.junit.Test;
+import org.junit.*;
 
+import rx.Observer;
 import rx.exceptions.*;
 import rx.functions.*;
 
@@ -186,4 +190,120 @@ public void testEmptyCompleted() {
         Action1<Throwable> throwAction = Actions.empty();
         Observers.create(Actions.empty(), throwAction).onCompleted();
     }
+    
+    @Test
+    public void onCompleteQueues() {
+        @SuppressWarnings("unchecked")
+        final Observer<Integer>[] observer = new Observer[] { null };
+        final boolean[] completeCalled = { false };
+        SerializedObserver<Integer> so = new SerializedObserver<Integer>(new Observer<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                observer[0].onNext(1);
+                observer[0].onCompleted();
+            }
+            
+            @Override
+            public void onError(Throwable e) {
+                
+            }
+            
+            @Override
+            public void onCompleted() {
+                completeCalled[0] = true;
+            }
+        });
+        observer[0] = so;
+        
+        so.onNext(1);
+        
+        Assert.assertTrue(completeCalled[0]);
+    }
+    
+    @Test
+    public void concurrentOnError() throws Exception {
+        final Queue<Throwable> queue = new ConcurrentLinkedQueue<Throwable>();
+        
+        final SerializedObserver<Integer> so = new SerializedObserver<Integer>(new Observer<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+            }
+            
+            @Override
+            public void onError(Throwable e) {
+                queue.offer(e);
+            }
+            
+            @Override
+            public void onCompleted() {
+            }
+        });
+
+        final CountDownLatch cdl = new CountDownLatch(1);
+        
+        synchronized (so) {
+            Thread t = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    so.onError(new IOException());
+                    cdl.countDown();
+                }
+            });
+            t.start();
+
+            Thread.sleep(200);
+            
+            so.onError(new TestException());
+        }
+        
+        if (!cdl.await(5, TimeUnit.SECONDS)) {
+            fail("The wait timed out");
+        }
+        
+        Assert.assertEquals(1, queue.size());
+        Throwable ex = queue.poll();
+        Assert.assertTrue("" + ex, ex instanceof TestException);
+    }
+    
+    @Test
+    public void concurrentOnComplete() throws Exception {
+        final int[] completed = { 0 };
+        final SerializedObserver<Integer> so = new SerializedObserver<Integer>(new Observer<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+            }
+            
+            @Override
+            public void onError(Throwable e) {
+            }
+            
+            @Override
+            public void onCompleted() {
+                completed[0]++;
+            }
+        });
+
+        final CountDownLatch cdl = new CountDownLatch(1);
+        
+        synchronized (so) {
+            Thread t = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    so.onCompleted();
+                    cdl.countDown();
+                }
+            });
+            t.start();
+
+            Thread.sleep(200);
+            
+            so.onCompleted();
+        }
+        
+        if (!cdl.await(5, TimeUnit.SECONDS)) {
+            fail("The wait timed out");
+        }
+        
+        Assert.assertEquals(1, completed[0]);
+    }
 }
diff --git a/src/test/java/rx/observers/SafeObserverTest.java b/src/test/java/rx/observers/SafeObserverTest.java
index 7924bb4026..0863ff9e50 100644
--- a/src/test/java/rx/observers/SafeObserverTest.java
+++ b/src/test/java/rx/observers/SafeObserverTest.java
@@ -22,7 +22,7 @@
 
 import org.junit.Test;
 
-import junit.framework.Assert;
+import org.junit.Assert;
 import rx.Subscriber;
 import rx.exceptions.*;
 import rx.functions.Action0;
diff --git a/src/test/java/rx/observers/SubscribersTest.java b/src/test/java/rx/observers/SubscribersTest.java
index 241ecae9af..e0e91d84b0 100644
--- a/src/test/java/rx/observers/SubscribersTest.java
+++ b/src/test/java/rx/observers/SubscribersTest.java
@@ -23,8 +23,10 @@
 
 import org.junit.Test;
 
+import rx.Subscriber;
 import rx.exceptions.*;
 import rx.functions.*;
+import rx.subscriptions.Subscriptions;
 
 public class SubscribersTest {
     @Test
@@ -185,4 +187,26 @@ public void testEmptyCompleted() {
         Action1<Throwable> throwAction = Actions.empty();
         Subscribers.create(Actions.empty(), throwAction).onCompleted();
     }
+    
+    @Test
+    public void shareSubscriptionButNullSubscriber() {
+        Subscriber<Integer> s = new Subscriber<Integer>(null, true) {
+            @Override
+            public void onNext(Integer t) {
+                
+            }
+            
+            @Override
+            public void onError(Throwable e) {
+                
+            }
+            
+            @Override
+            public void onCompleted() {
+                
+            }
+        };
+        
+        s.add(Subscriptions.empty());
+    }
 }
diff --git a/src/test/java/rx/observers/TestSubscriberTest.java b/src/test/java/rx/observers/TestSubscriberTest.java
index 9ff09edd20..6cee089f41 100644
--- a/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/src/test/java/rx/observers/TestSubscriberTest.java
@@ -335,9 +335,9 @@ public void testMultipleErrors3() {
     @Test
     public void testDifferentError() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        ts.onError(new TestException());
+        ts.onError(new TestException("First error"));
         try {
-            ts.assertError(new TestException());
+            ts.assertError(new TestException("Other error"));
         } catch (AssertionError ex) {
             // expected
             return;
diff --git a/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index f27c43807c..e1252e7214 100644
--- a/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -15,34 +15,23 @@
  */
 package rx.schedulers;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
-
-import org.junit.Test;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+import org.junit.*;
 import org.mockito.InOrder;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
+import rx.*;
 import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.functions.Func1;
+import rx.Scheduler.Worker;
+import rx.functions.*;
 
 /**
  * Base tests for all schedulers including Immediate/Current.
@@ -501,5 +490,43 @@ public void onNext(T args) {
         }
 
     }
+    
+    @Test
+    public void periodicTaskCancelsItself() throws Exception {
+        Scheduler scheduler = getScheduler();
+        if (scheduler instanceof rx.internal.schedulers.ImmediateScheduler 
+                || scheduler instanceof rx.internal.schedulers.TrampolineScheduler) {
+            return;
+        }
+        Worker w = scheduler.createWorker();
+        
+        try {
+            final CountDownLatch cdl = new CountDownLatch(1);
+            final int[] executions = { 0 };
+            final AtomicReference<Subscription> cancel = new AtomicReference<Subscription>();
+            Subscription s = w.schedulePeriodically(new Action0() {
+                @Override
+                public void call() {
+                    executions[0]++;
+                    while (cancel.get() == null);
+                    
+                    cancel.get().unsubscribe();
+                    cdl.countDown();
+                }
+            }, 100, 100, TimeUnit.MILLISECONDS);
+            
+            cancel.set(s);
+            
+            if (!cdl.await(5, TimeUnit.SECONDS)) {
+                s.unsubscribe();
+                Assert.fail("The await timed out");
+            }
+            
+            Assert.assertEquals(1, executions[0]);
+            
+        } finally {
+            w.unsubscribe();
+        }
+    }
 
 }
diff --git a/src/test/java/rx/schedulers/NewThreadSchedulerTest.java b/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
index 1c10843af0..48fa0d9887 100644
--- a/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
+++ b/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
@@ -20,7 +20,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
-import junit.framework.Assert;
+import org.junit.Assert;
 
 import org.junit.Test;
 
diff --git a/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java b/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
index 593e96c528..14e57537d5 100644
--- a/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
@@ -24,8 +24,8 @@
 import org.junit.*;
 
 import rx.*;
-import rx.Observable.OnSubscribe;
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.functions.*;
 import rx.observers.TestSubscriber;
@@ -222,7 +222,6 @@ public void run() {
         for (Thread t : threads) {
             t.join();
         }
-
         StringBuilder sb = new StringBuilder();
 
         // assert all threads got the same results
diff --git a/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java b/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
index d9563b001f..358f500ec3 100644
--- a/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
+++ b/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
@@ -20,7 +20,7 @@
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static rx.subscriptions.Subscriptions.create;
-import junit.framework.Assert;
+import org.junit.Assert;
 
 import org.junit.Before;
 import org.junit.Test;

From 54eeaca04c8b36785971a9a573cb4c185ab0c974 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 22 Jun 2016 11:09:10 +0200
Subject: [PATCH 069/263] 1.x: Deprecate TestObserver, enhance TestSubscriber a
 bit (#4011)

---
 src/main/java/rx/observers/TestObserver.java  |   2 +
 .../java/rx/observers/TestSubscriber.java     | 228 ++++++++++++++----
 .../operators/CachedObservableTest.java       |   6 +-
 .../OnSubscribeToObservableFutureTest.java    |   8 +-
 .../internal/operators/OperatorDelayTest.java |   3 +-
 .../operators/OperatorFlatMapTest.java        |   4 +-
 .../OperatorMergeMaxConcurrentTest.java       |   2 +-
 .../internal/operators/OperatorMergeTest.java |  16 +-
 .../OperatorOnBackpressureLatestTest.java     |   2 +-
 .../operators/OperatorPublishTest.java        |   6 +-
 .../operators/OperatorReplayTest.java         |   6 +-
 .../internal/operators/OperatorRetryTest.java |   2 +-
 .../operators/OperatorSubscribeOnTest.java    |   5 +-
 .../operators/OperatorSwitchTest.java         |   2 +-
 .../OperatorTakeUntilPredicateTest.java       |   2 +-
 .../operators/OperatorTakeUntilTest.java      |   5 +-
 .../OperatorToObservableListTest.java         |   6 +-
 .../OperatorToObservableSortedListTest.java   |   6 +-
 .../operators/OperatorUnsubscribeOnTest.java  |  15 +-
 .../operators/OperatorWithLatestFromTest.java |   2 +-
 .../rx/internal/producers/ProducersTest.java  |   8 +-
 .../rx/observers/SerializedObserverTest.java  |  14 +-
 .../java/rx/observers/TestObserverTest.java   |   1 +
 .../java/rx/observers/TestSubscriberTest.java |  67 ++++-
 24 files changed, 302 insertions(+), 116 deletions(-)

diff --git a/src/main/java/rx/observers/TestObserver.java b/src/main/java/rx/observers/TestObserver.java
index baa0f1323d..fa7d19dd61 100644
--- a/src/main/java/rx/observers/TestObserver.java
+++ b/src/main/java/rx/observers/TestObserver.java
@@ -24,7 +24,9 @@
 /**
  * Observer usable for unit testing to perform assertions, inspect received events or wrap a mocked Observer.
  * @param <T> the observed value type
+ * @deprecated use the {@link TestSubscriber} insteand.
  */
+@Deprecated
 public class TestObserver<T> implements Observer<T> {
 
     private final Observer<T> delegate;
diff --git a/src/main/java/rx/observers/TestSubscriber.java b/src/main/java/rx/observers/TestSubscriber.java
index 5c64b3a8f8..ce973fe861 100644
--- a/src/main/java/rx/observers/TestSubscriber.java
+++ b/src/main/java/rx/observers/TestSubscriber.java
@@ -20,6 +20,7 @@
 
 import rx.*;
 import rx.Observer;
+import rx.annotations.Experimental;
 import rx.exceptions.CompositeException;
 
 /**
@@ -29,8 +30,20 @@
  */
 public class TestSubscriber<T> extends Subscriber<T> {
 
-    private final TestObserver<T> testObserver;
+    private final Observer<T> delegate;
+    
+    private final List<T> values;
+    
+    private final List<Throwable> errors;
+    
+    /** The number of onCompleted() calls. */
+    private int completions;
+    
     private final CountDownLatch latch = new CountDownLatch(1);
+    
+    /** Written after an onNext value has been added to the {@link #values} list. */
+    private volatile int valueCount;
+    
     private volatile Thread lastSeenThread;
     /** The shared no-op observer. */
     private static final Observer<Object> INERT = new Observer<Object>() {
@@ -76,10 +89,13 @@ public TestSubscriber(Observer<T> delegate, long initialRequest) {
         if (delegate == null) {
             throw new NullPointerException();
         }
-        this.testObserver = new TestObserver<T>(delegate);
+        this.delegate = delegate;
         if (initialRequest >= 0L) {
             this.request(initialRequest);
         }
+        
+        this.values = new ArrayList<T>();
+        this.errors = new ArrayList<Throwable>();
     }
 
     /**
@@ -180,8 +196,9 @@ public static <T> TestSubscriber<T> create(Observer<T> delegate) {
     @Override
     public void onCompleted() {
         try {
+            completions++;
             lastSeenThread = Thread.currentThread();
-            testObserver.onCompleted();
+            delegate.onCompleted();
         } finally {
             latch.countDown();
         }
@@ -192,9 +209,27 @@ public void onCompleted() {
      * completion via {@link #onCompleted}, as a {@link List}.
      *
      * @return a list of Notifications representing calls to this Subscriber's {@link #onCompleted} method
+     * 
+     * @deprecated use {@link #getCompletions()} instead.
      */
+    @Deprecated
     public List<Notification<T>> getOnCompletedEvents() {
-        return testObserver.getOnCompletedEvents();
+        int c = completions;
+        List<Notification<T>> result = new ArrayList<Notification<T>>(c != 0 ? c : 1);
+        for (int i = 0; i < c; i++) {
+            result.add(Notification.<T>createOnCompleted());
+        }
+        return result;
+    }
+    
+    /**
+     * Returns the number of times onCompleted was called on this TestSubscriber.
+     * @return the number of times onCompleted was called on this TestSubscriber.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final int getCompletions() {
+        return completions;
     }
 
     /**
@@ -210,7 +245,8 @@ public List<Notification<T>> getOnCompletedEvents() {
     public void onError(Throwable e) {
         try {
             lastSeenThread = Thread.currentThread();
-            testObserver.onError(e);
+            errors.add(e);
+            delegate.onError(e);
         } finally {
             latch.countDown();
         }
@@ -223,7 +259,7 @@ public void onError(Throwable e) {
      * @return a list of the Throwables that were passed to this Subscriber's {@link #onError} method
      */
     public List<Throwable> getOnErrorEvents() {
-        return testObserver.getOnErrorEvents();
+        return errors;
     }
 
     /**
@@ -240,7 +276,18 @@ public List<Throwable> getOnErrorEvents() {
     @Override
     public void onNext(T t) {
         lastSeenThread = Thread.currentThread();
-        testObserver.onNext(t);
+        values.add(t);
+        valueCount = values.size();
+        delegate.onNext(t);
+    }
+    
+    /**
+     * Returns the committed number of onNext elements that are safe to be
+     * read from {@link #getOnNextEvents()} other threads.
+     * @return the committed number of onNext elements
+     */
+    public final int getValueCount() {
+        return valueCount;
     }
     
     /**
@@ -259,7 +306,7 @@ public void requestMore(long n) {
      * @return a list of items observed by this Subscriber, in the order in which they were observed
      */
     public List<T> getOnNextEvents() {
-        return testObserver.getOnNextEvents();
+        return values;
     }
 
     /**
@@ -271,9 +318,52 @@ public List<T> getOnNextEvents() {
      *          if the sequence of items observed does not exactly match {@code items}
      */
     public void assertReceivedOnNext(List<T> items) {
-        testObserver.assertReceivedOnNext(items);
+        if (values.size() != items.size()) {
+            assertionError("Number of items does not match. Provided: " + items.size() + "  Actual: " + values.size()
+            + ".\n"
+            + "Provided values: " + items
+            + "\n"
+            + "Actual values: " + values
+            + "\n");
+        }
+
+        for (int i = 0; i < items.size(); i++) {
+            T expected = items.get(i);
+            T actual = values.get(i);
+            if (expected == null) {
+                // check for null equality
+                if (actual != null) {
+                    assertionError("Value at index: " + i + " expected to be [null] but was: [" + actual + "]\n");
+                }
+            } else if (!expected.equals(actual)) {
+                assertionError("Value at index: " + i 
+                        + " expected to be [" + expected + "] (" + expected.getClass().getSimpleName() 
+                        + ") but was: [" + actual + "] (" + (actual != null ? actual.getClass().getSimpleName() : "null") + ")\n");
+
+            }
+        }
     }
 
+    /**
+     * Wait until the current committed value count is less than the expected amount
+     * by sleeping 1 unit at most timeout times and return true if at least
+     * the required amount of onNext values have been received.
+     * @param expected the expected number of onNext events
+     * @param timeout the time to wait for the events
+     * @param unit the time unit of waiting
+     * @return true if the expected number of onNext events happened
+     * @throws InterruptedException if the sleep is interrupted
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final boolean awaitValueCount(int expected, long timeout, TimeUnit unit) throws InterruptedException {
+        while (timeout != 0 && valueCount < expected) {
+            unit.sleep(1);
+            timeout--;
+        }
+        return valueCount >= expected;
+    }
+    
     /**
      * Asserts that a single terminal event occurred, either {@link #onCompleted} or {@link #onError}.
      *
@@ -281,7 +371,21 @@ public void assertReceivedOnNext(List<T> items) {
      *          if not exactly one terminal event notification was received
      */
     public void assertTerminalEvent() {
-        testObserver.assertTerminalEvent();
+        if (errors.size() > 1) {
+            assertionError("Too many onError events: " + errors.size());
+        }
+
+        if (completions > 1) {
+            assertionError("Too many onCompleted events: " + completions);
+        }
+
+        if (completions == 1 && errors.size() == 1) {
+            assertionError("Received both an onError and onCompleted. Should be one or the other.");
+        }
+
+        if (completions == 0 && errors.size() == 0) {
+            assertionError("No terminal events received.");
+        }
     }
 
     /**
@@ -292,7 +396,7 @@ public void assertTerminalEvent() {
      */
     public void assertUnsubscribed() {
         if (!isUnsubscribed()) {
-            testObserver.assertionError("Not unsubscribed.");
+            assertionError("Not unsubscribed.");
         }
     }
 
@@ -305,13 +409,7 @@ public void assertUnsubscribed() {
     public void assertNoErrors() {
         List<Throwable> onErrorEvents = getOnErrorEvents();
         if (onErrorEvents.size() > 0) {
-            AssertionError ae = new AssertionError("Unexpected onError events: " + getOnErrorEvents().size());
-            if (onErrorEvents.size() == 1) {
-                ae.initCause(getOnErrorEvents().get(0));
-            } else {
-                ae.initCause(new CompositeException(onErrorEvents));
-            }
-            throw ae;
+            assertionError("Unexpected onError events");
         }
     }
 
@@ -391,12 +489,12 @@ public Thread getLastSeenThread() {
      * @since 1.1.0
      */
     public void assertCompleted() {
-        int s = testObserver.getOnCompletedEvents().size();
+        int s = completions;
         if (s == 0) {
-            testObserver.assertionError("Not completed!");
+            assertionError("Not completed!");
         } else
         if (s > 1) {
-            testObserver.assertionError("Completed multiple times: " + s);
+            assertionError("Completed multiple times: " + s);
         }
     }
 
@@ -407,12 +505,12 @@ public void assertCompleted() {
      * @since 1.1.0
      */
     public void assertNotCompleted() {
-        int s = testObserver.getOnCompletedEvents().size();
+        int s = completions;
         if (s == 1) {
-            testObserver.assertionError("Completed!");
+            assertionError("Completed!");
         } else
         if (s > 1) {
-            testObserver.assertionError("Completed multiple times: " + s);
+            assertionError("Completed multiple times: " + s);
         }
     }
 
@@ -425,9 +523,9 @@ public void assertNotCompleted() {
      * @since 1.1.0
      */
     public void assertError(Class<? extends Throwable> clazz) {
-        List<Throwable> err = testObserver.getOnErrorEvents();
+        List<Throwable> err = errors;
         if (err.size() == 0) {
-            testObserver.assertionError("No errors");
+            assertionError("No errors");
         } else
         if (err.size() > 1) {
             AssertionError ae = new AssertionError("Multiple errors: " + err.size());
@@ -450,19 +548,15 @@ public void assertError(Class<? extends Throwable> clazz) {
      * @since 1.1.0
      */
     public void assertError(Throwable throwable) {
-        List<Throwable> err = testObserver.getOnErrorEvents();
+        List<Throwable> err = errors;
         if (err.size() == 0) {
-            testObserver.assertionError("No errors");
+            assertionError("No errors");
         } else
         if (err.size() > 1) {
-            AssertionError ae = new AssertionError("Multiple errors: " + err.size());
-            ae.initCause(new CompositeException(err));
-            throw ae;
+            assertionError("Multiple errors");
         } else
         if (!throwable.equals(err.get(0))) {
-            AssertionError ae = new AssertionError("Exceptions differ; expected: " + throwable + ", actual: " + err.get(0));
-            ae.initCause(err.get(0));
-            throw ae;
+            assertionError("Exceptions differ; expected: " + throwable + ", actual: " + err.get(0));
         }
     }
 
@@ -473,20 +567,16 @@ public void assertError(Throwable throwable) {
      * @since 1.1.0
      */
     public void assertNoTerminalEvent() {
-        List<Throwable> err = testObserver.getOnErrorEvents();
-        int s = testObserver.getOnCompletedEvents().size();
+        List<Throwable> err = errors;
+        int s = completions;
         if (err.size() > 0 || s > 0) {
             if (err.isEmpty()) {
-                testObserver.assertionError("Found " + err.size() + " errors and " + s + " completion events instead of none");
+                assertionError("Found " + err.size() + " errors and " + s + " completion events instead of none");
             } else
             if (err.size() == 1) {
-                AssertionError ae = new AssertionError("Found " + err.size() + " errors and " + s + " completion events instead of none");
-                ae.initCause(err.get(0));
-                throw ae;
+                assertionError("Found " + err.size() + " errors and " + s + " completion events instead of none");
             } else {
-                AssertionError ae = new AssertionError("Found " + err.size() + " errors and " + s + " completion events instead of none");
-                ae.initCause(new CompositeException(err));
-                throw ae;
+                assertionError("Found " + err.size() + " errors and " + s + " completion events instead of none");
             }
         }
     }
@@ -498,9 +588,9 @@ public void assertNoTerminalEvent() {
      * @since 1.1.0
      */
     public void assertNoValues() {
-        int s = testObserver.getOnNextEvents().size();
-        if (s > 0) {
-            testObserver.assertionError("No onNext events expected yet some received: " + s);
+        int s = values.size();
+        if (s != 0) {
+            assertionError("No onNext events expected yet some received: " + s);
         }
     }
 
@@ -512,9 +602,9 @@ public void assertNoValues() {
      * @since 1.1.0
      */
     public void assertValueCount(int count) {
-        int s = testObserver.getOnNextEvents().size();
+        int s = values.size();
         if (s != count) {
-            testObserver.assertionError("Number of onNext events differ; expected: " + count + ", actual: " + s);
+            assertionError("Number of onNext events differ; expected: " + count + ", actual: " + s);
         }
     }
     
@@ -539,4 +629,46 @@ public void assertValues(T... values) {
     public void assertValue(T value) {
         assertReceivedOnNext(Collections.singletonList(value));
     }
+    
+    /**
+     * Combines an assertion error message with the current completion and error state of this
+     * TestSubscriber, giving more information when some assertXXX check fails.
+     * @param message the message to use for the error
+     */
+    final void assertionError(String message) {
+        StringBuilder b = new StringBuilder(message.length() + 32);
+        
+        b.append(message);
+        
+        
+        b.append(" (");
+        int c = completions;
+        b.append(c);
+        b.append(" completion");
+        if (c != 1) {
+            b.append("s");
+        }
+        b.append(")");
+        
+        if (!errors.isEmpty()) {
+            int size = errors.size();
+            b.append(" (+")
+            .append(size)
+            .append(" error");
+            if (size != 1) {
+                b.append("s");
+            }
+            b.append(")");
+        }
+        
+        AssertionError ae = new AssertionError(b.toString());
+        if (!errors.isEmpty()) {
+            if (errors.size() == 1) {
+                ae.initCause(errors.get(0));
+            } else {
+                ae.initCause(new CompositeException(errors));
+            }
+        }
+        throw ae;
+    }
 }
diff --git a/src/test/java/rx/internal/operators/CachedObservableTest.java b/src/test/java/rx/internal/operators/CachedObservableTest.java
index ec88045dcb..b1ef245485 100644
--- a/src/test/java/rx/internal/operators/CachedObservableTest.java
+++ b/src/test/java/rx/internal/operators/CachedObservableTest.java
@@ -70,7 +70,7 @@ public void testColdReplayBackpressure() {
         assertTrue("Subscribers not retained!", source.hasObservers());
         
         ts.assertNoErrors();
-        assertTrue(ts.getOnCompletedEvents().isEmpty());
+        assertEquals(0, ts.getCompletions());
         List<Integer> onNextEvents = ts.getOnNextEvents();
         assertEquals(10, onNextEvents.size());
 
@@ -251,14 +251,14 @@ public void testValuesAndThenError() {
         source.subscribe(ts);
         
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-        Assert.assertTrue(ts.getOnCompletedEvents().isEmpty());
+        Assert.assertEquals(0, ts.getCompletions());
         Assert.assertEquals(1, ts.getOnErrorEvents().size());
         
         TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>();
         source.subscribe(ts2);
         
         ts2.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-        Assert.assertTrue(ts2.getOnCompletedEvents().isEmpty());
+        Assert.assertEquals(0, ts2.getCompletions());
         Assert.assertEquals(1, ts2.getOnErrorEvents().size());
     }
     
diff --git a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
index 4740b97aa0..9734cc4c41 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
@@ -39,7 +39,7 @@ public void testSuccess() throws Exception {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
-        Subscription sub = Observable.from(future).subscribe(new TestObserver<Object>(o));
+        Subscription sub = Observable.from(future).subscribe(new TestSubscriber<Object>(o));
         sub.unsubscribe();
 
         verify(o, times(1)).onNext(value);
@@ -57,7 +57,7 @@ public void testFailure() throws Exception {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
-        Subscription sub = Observable.from(future).subscribe(new TestObserver<Object>(o));
+        Subscription sub = Observable.from(future).subscribe(new TestSubscriber<Object>(o));
         sub.unsubscribe();
 
         verify(o, never()).onNext(null);
@@ -79,7 +79,7 @@ public void testCancelledBeforeSubscribe() throws Exception {
         testSubscriber.unsubscribe();
         Observable.from(future).subscribe(testSubscriber);
         assertEquals(0, testSubscriber.getOnErrorEvents().size());
-        assertEquals(0, testSubscriber.getOnCompletedEvents().size());
+        assertEquals(0, testSubscriber.getCompletions());
     }
 
     @Test
@@ -125,7 +125,7 @@ public Object get(long timeout, TimeUnit unit) throws InterruptedException, Exec
         Subscription sub = futureObservable.subscribeOn(Schedulers.computation()).subscribe(testSubscriber);
         sub.unsubscribe();
         assertEquals(0, testSubscriber.getOnErrorEvents().size());
-        assertEquals(0, testSubscriber.getOnCompletedEvents().size());
+        assertEquals(0, testSubscriber.getCompletions());
         assertEquals(0, testSubscriber.getOnNextEvents().size());
     }
     
diff --git a/src/test/java/rx/internal/operators/OperatorDelayTest.java b/src/test/java/rx/internal/operators/OperatorDelayTest.java
index 315248a5db..470e83ddc5 100644
--- a/src/test/java/rx/internal/operators/OperatorDelayTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDelayTest.java
@@ -43,7 +43,6 @@
 import rx.exceptions.TestException;
 import rx.functions.*;
 import rx.internal.util.RxRingBuffer;
-import rx.observers.TestObserver;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
@@ -657,7 +656,7 @@ public void call(Notification<? super Integer> t1) {
             }
 
         });
-        TestObserver<Integer> observer = new TestObserver<Integer>();
+        TestSubscriber<Integer> observer = new TestSubscriber<Integer>();
         delayed.subscribe(observer);
         // all will be delivered after 500ms since range does not delay between them
         scheduler.advanceTimeBy(500L, TimeUnit.MILLISECONDS);
diff --git a/src/test/java/rx/internal/operators/OperatorFlatMapTest.java b/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
index 8213252c85..ce9712851a 100644
--- a/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
+++ b/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
@@ -449,7 +449,7 @@ public Observable<Integer> call(Integer t) {
             .subscribe(ts);
 
             ts.awaitTerminalEvent(2500, TimeUnit.MILLISECONDS);
-            if (ts.getOnCompletedEvents().isEmpty()) {
+            if (ts.getCompletions() == 0) {
                 System.out.println(ts.getOnNextEvents().size());
             }
             ts.assertTerminalEvent();
@@ -491,7 +491,7 @@ public Observable<Integer> call(Integer t) {
             .subscribe(ts);
 
             ts.awaitTerminalEvent(2500, TimeUnit.MILLISECONDS);
-            if (ts.getOnCompletedEvents().isEmpty()) {
+            if (ts.getCompletions() == 0) {
                 System.out.println(ts.getOnNextEvents().size());
             }
             ts.assertTerminalEvent();
diff --git a/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java b/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
index 128af7cb8e..f383853f6f 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
@@ -281,7 +281,7 @@ public void onNext(Integer t) {
         
         ts.assertNoErrors();
         assertEquals(5, ts.getOnNextEvents().size());
-        assertEquals(0, ts.getOnCompletedEvents().size());
+        assertEquals(0, ts.getCompletions());
         
         ts.unsubscribe();
     }
diff --git a/src/test/java/rx/internal/operators/OperatorMergeTest.java b/src/test/java/rx/internal/operators/OperatorMergeTest.java
index 9d938cc002..f410a55685 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeTest.java
@@ -486,10 +486,10 @@ public void testConcurrency() {
             ts.awaitTerminalEvent(3, TimeUnit.SECONDS);
             ts.assertTerminalEvent();
             ts.assertNoErrors();
-            assertEquals(1, ts.getOnCompletedEvents().size());
+            assertEquals(1, ts.getCompletions());
             List<Integer> onNextEvents = ts.getOnNextEvents();
             assertEquals(30000, onNextEvents.size());
-            //            System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getOnCompletedEvents().size());
+            //            System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getCompletions().size());
         }
     }
 
@@ -531,10 +531,10 @@ public void call() {
             merge.subscribe(ts);
 
             ts.awaitTerminalEvent();
-            assertEquals(1, ts.getOnCompletedEvents().size());
+            assertEquals(1, ts.getCompletions());
             List<Integer> onNextEvents = ts.getOnNextEvents();
             assertEquals(300, onNextEvents.size());
-            //            System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getOnCompletedEvents().size());
+            //            System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getCompletions().size());
         }
     }
 
@@ -573,10 +573,10 @@ public void call() {
 
             ts.awaitTerminalEvent();
             ts.assertNoErrors();
-            assertEquals(1, ts.getOnCompletedEvents().size());
+            assertEquals(1, ts.getCompletions());
             List<Integer> onNextEvents = ts.getOnNextEvents();
             assertEquals(30000, onNextEvents.size());
-            //                System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getOnCompletedEvents().size());
+            //                System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getCompletions().size());
         }
     }
 
@@ -1034,11 +1034,11 @@ public void shouldNotCompleteIfThereArePendingScalarSynchronousEmissionsWhenTheL
         source.subscribe(subscriber);
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
         subscriber.assertReceivedOnNext(Collections.<Long>emptyList());
-        assertEquals(Collections.<Notification<Long>>emptyList(), subscriber.getOnCompletedEvents());
+        assertEquals(0, subscriber.getCompletions());
         subscriber.requestMore(1);
         subscriber.assertReceivedOnNext(asList(1L));
 // TODO: it should be acceptable to get a completion event without requests
-//        assertEquals(Collections.<Notification<Long>>emptyList(), subscriber.getOnCompletedEvents());
+//        assertEquals(Collections.<Notification<Long>>emptyList(), subscriber.getCompletions());
 //        subscriber.requestMore(1);
         subscriber.assertTerminalEvent();
     }
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java
index 2b40ac772b..30751f311f 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java
@@ -62,7 +62,7 @@ public void onStart() {
         
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2));
-        Assert.assertTrue(ts.getOnCompletedEvents().isEmpty());
+        Assert.assertEquals(0, ts.getCompletions());
     }
     @Test
     public void testSynchronousDrop() {
diff --git a/src/test/java/rx/internal/operators/OperatorPublishTest.java b/src/test/java/rx/internal/operators/OperatorPublishTest.java
index f247638891..0ba6e757bd 100644
--- a/src/test/java/rx/internal/operators/OperatorPublishTest.java
+++ b/src/test/java/rx/internal/operators/OperatorPublishTest.java
@@ -299,7 +299,7 @@ public void testNoSubscriberRetentionOnCompleted() {
 
         ts1.assertReceivedOnNext(Arrays.<Integer>asList());
         ts1.assertNoErrors();
-        assertTrue(ts1.getOnCompletedEvents().isEmpty());
+        assertEquals(0, ts1.getCompletions());
         
         source.connect();
 
@@ -351,13 +351,13 @@ public void onStart() {
         
         ts.assertReceivedOnNext(Arrays.<Integer>asList());
         ts.assertNoErrors();
-        assertTrue(ts.getOnCompletedEvents().isEmpty());
+        assertEquals(0, ts.getCompletions());
         
         source.connect();
 
         ts.assertReceivedOnNext(Arrays.<Integer>asList());
         ts.assertNoErrors();
-        assertTrue(ts.getOnCompletedEvents().isEmpty());
+        assertEquals(0, ts.getCompletions());
         
         ts.requestMore(5);
         
diff --git a/src/test/java/rx/internal/operators/OperatorReplayTest.java b/src/test/java/rx/internal/operators/OperatorReplayTest.java
index 4d7f184951..fb741991d7 100644
--- a/src/test/java/rx/internal/operators/OperatorReplayTest.java
+++ b/src/test/java/rx/internal/operators/OperatorReplayTest.java
@@ -913,7 +913,7 @@ public void testColdReplayBackpressure() {
         source.subscribe(ts);
 
         ts.assertNoErrors();
-        assertTrue(ts.getOnCompletedEvents().isEmpty());
+        assertEquals(0, ts.getCompletions());
         List<Integer> onNextEvents = ts.getOnNextEvents();
         assertEquals(10, onNextEvents.size());
 
@@ -1098,14 +1098,14 @@ public void testValuesAndThenError() {
         source.subscribe(ts);
         
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-        Assert.assertTrue(ts.getOnCompletedEvents().isEmpty());
+        Assert.assertEquals(0, ts.getCompletions());
         Assert.assertEquals(1, ts.getOnErrorEvents().size());
         
         TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>();
         source.subscribe(ts2);
         
         ts2.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-        Assert.assertTrue(ts2.getOnCompletedEvents().isEmpty());
+        Assert.assertEquals(0, ts2.getCompletions());
         Assert.assertEquals(1, ts2.getOnErrorEvents().size());
     }
     
diff --git a/src/test/java/rx/internal/operators/OperatorRetryTest.java b/src/test/java/rx/internal/operators/OperatorRetryTest.java
index b80aeef70a..b461289130 100644
--- a/src/test/java/rx/internal/operators/OperatorRetryTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRetryTest.java
@@ -752,7 +752,7 @@ public void run() {
                                     for (Throwable t : ts.getOnErrorEvents()) {
                                         onNextEvents.add(t.toString());
                                     }
-                                    for (int k = 0; k < ts.getOnCompletedEvents().size(); k++) {
+                                    for (int k = 0; k < ts.getCompletions(); k++) {
                                         onNextEvents.add("onCompleted");
                                     }
                                     data.put(j, onNextEvents);
diff --git a/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java b/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
index 6a87a383c9..0c72ebaf7a 100644
--- a/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
@@ -35,7 +35,6 @@
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
-import rx.observers.TestObserver;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 
@@ -48,7 +47,7 @@ public void testIssue813() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         final CountDownLatch doneLatch = new CountDownLatch(1);
 
-        TestObserver<Integer> observer = new TestObserver<Integer>();
+        TestSubscriber<Integer> observer = new TestSubscriber<Integer>();
 
         final Subscription subscription = Observable
                 .create(new Observable.OnSubscribe<Integer>() {
@@ -80,7 +79,7 @@ public void call(
         latch.countDown();
         doneLatch.await();
         assertEquals(0, observer.getOnErrorEvents().size());
-        assertEquals(1, observer.getOnCompletedEvents().size());
+        assertEquals(1, observer.getCompletions());
     }
 
     @Test
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchTest.java b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
index d11c44ec2c..c1fcf8d534 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
@@ -876,7 +876,7 @@ public void call(Throwable e) {
                 throw new AssertionError("Dropped exceptions", new CompositeException(q));
             }
             ts.assertNoErrors();
-            if (ts.getOnCompletedEvents().size() == 0) {
+            if (ts.getCompletions() == 0) {
                 fail("switchAsyncHeavily timed out @ " + j + " (" + ts.getOnNextEvents().size() + " onNexts received, last was " + (System.currentTimeMillis() - lastSeen[0]) + " ms ago");
             }
         }
diff --git a/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java b/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java
index f1c9e47f1b..06b75c05f4 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java
@@ -132,7 +132,7 @@ public void onStart() {
         
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5));
-        Assert.assertEquals(0, ts.getOnCompletedEvents().size());
+        Assert.assertEquals(0, ts.getCompletions());
     }
     
     @Test
diff --git a/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java b/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
index 1667d306f8..5ffada913e 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
@@ -15,8 +15,7 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
@@ -281,7 +280,7 @@ public void onStart() {
         
         ts.assertReceivedOnNext(Arrays.asList(1));
         ts.assertNoErrors();
-        assertTrue("TestSubscriber completed", ts.getOnCompletedEvents().isEmpty());
+        assertEquals("TestSubscriber completed", 0, ts.getCompletions());
         
         assertFalse("Until still has observers", until.hasObservers());
         assertFalse("TestSubscriber is unsubscribed", ts.isUnsubscribed());
diff --git a/src/test/java/rx/internal/operators/OperatorToObservableListTest.java b/src/test/java/rx/internal/operators/OperatorToObservableListTest.java
index c38786b286..1bf0041d57 100644
--- a/src/test/java/rx/internal/operators/OperatorToObservableListTest.java
+++ b/src/test/java/rx/internal/operators/OperatorToObservableListTest.java
@@ -121,19 +121,19 @@ public void onStart() {
         
         assertTrue(ts.getOnNextEvents().isEmpty());
         assertTrue(ts.getOnErrorEvents().isEmpty());
-        assertTrue(ts.getOnCompletedEvents().isEmpty());
+        assertEquals(0, ts.getCompletions());
         
         ts.requestMore(1);
         
         ts.assertReceivedOnNext(Collections.singletonList(Arrays.asList(1, 2, 3, 4, 5)));
         assertTrue(ts.getOnErrorEvents().isEmpty());
-        assertEquals(1, ts.getOnCompletedEvents().size());
+        assertEquals(1, ts.getCompletions());
 
         ts.requestMore(1);
 
         ts.assertReceivedOnNext(Collections.singletonList(Arrays.asList(1, 2, 3, 4, 5)));
         assertTrue(ts.getOnErrorEvents().isEmpty());
-        assertEquals(1, ts.getOnCompletedEvents().size());
+        assertEquals(1, ts.getCompletions());
     }
     @Test(timeout = 2000)
     public void testAsyncRequested() {
diff --git a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
index 0b1d64bf87..f687fb2b28 100644
--- a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
+++ b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
@@ -87,19 +87,19 @@ public void onStart() {
         
         assertTrue(ts.getOnNextEvents().isEmpty());
         assertTrue(ts.getOnErrorEvents().isEmpty());
-        assertTrue(ts.getOnCompletedEvents().isEmpty());
+        assertEquals(0, ts.getCompletions());
         
         ts.requestMore(1);
         
         ts.assertReceivedOnNext(Collections.singletonList(Arrays.asList(1, 2, 3, 4, 5)));
         assertTrue(ts.getOnErrorEvents().isEmpty());
-        assertEquals(1, ts.getOnCompletedEvents().size());
+        assertEquals(1, ts.getCompletions());
 
         ts.requestMore(1);
 
         ts.assertReceivedOnNext(Collections.singletonList(Arrays.asList(1, 2, 3, 4, 5)));
         assertTrue(ts.getOnErrorEvents().isEmpty());
-        assertEquals(1, ts.getOnCompletedEvents().size());
+        assertEquals(1, ts.getCompletions());
     }
     @Test(timeout = 2000)
     public void testAsyncRequested() {
diff --git a/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java b/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
index 4be8b96298..9e9b946f28 100644
--- a/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
@@ -15,9 +15,7 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 
 import java.util.Arrays;
 import java.util.concurrent.*;
@@ -25,14 +23,11 @@
 
 import org.junit.Test;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.Subscription;
 import rx.functions.Action0;
 import rx.internal.util.RxThreadFactory;
-import rx.observers.TestObserver;
+import rx.observers.*;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 
@@ -56,7 +51,7 @@ public void call(Subscriber<? super Integer> t1) {
                 }
             });
 
-            TestObserver<Integer> observer = new TestObserver<Integer>();
+            TestSubscriber<Integer> observer = new TestSubscriber<Integer>();
             w
             .subscribeOn(UI_EVENT_LOOP)
             .observeOn(Schedulers.computation())
@@ -101,7 +96,7 @@ public void call(Subscriber<? super Integer> t1) {
                 }
             });
 
-            TestObserver<Integer> observer = new TestObserver<Integer>();
+            TestSubscriber<Integer> observer = new TestSubscriber<Integer>();
             w
             .subscribeOn(Schedulers.newThread())
             .observeOn(Schedulers.computation())
diff --git a/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java b/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java
index a0a6a9d20c..69506a5d66 100644
--- a/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java
+++ b/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java
@@ -155,7 +155,7 @@ public void testUnsubscription() {
         
         ts.assertReceivedOnNext(Arrays.asList((1 << 8) + 1));
         ts.assertNoErrors();
-        assertEquals(0, ts.getOnCompletedEvents().size());
+        assertEquals(0, ts.getCompletions());
         
         assertFalse(source.hasObservers());
         assertFalse(other.hasObservers());
diff --git a/src/test/java/rx/internal/producers/ProducersTest.java b/src/test/java/rx/internal/producers/ProducersTest.java
index 81377f29a3..cda5a17d32 100644
--- a/src/test/java/rx/internal/producers/ProducersTest.java
+++ b/src/test/java/rx/internal/producers/ProducersTest.java
@@ -51,7 +51,7 @@ public void testSingleWithBackpressure() {
         
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
-        Assert.assertTrue(ts.getOnCompletedEvents().isEmpty());
+        Assert.assertEquals(0, ts.getCompletions());
         
         ts.requestMore(2);
         
@@ -68,7 +68,7 @@ public void testSingleDelayedNoBackpressure() {
 
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
-        Assert.assertTrue(ts.getOnCompletedEvents().isEmpty());
+        Assert.assertEquals(0, ts.getCompletions());
         
         sdp.setValue(1);
         
@@ -89,13 +89,13 @@ public void testSingleDelayedWithBackpressure() {
 
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
-        Assert.assertTrue(ts.getOnCompletedEvents().isEmpty());
+        Assert.assertEquals(0, ts.getCompletions());
         
         sdp.setValue(1);
 
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
-        Assert.assertTrue(ts.getOnCompletedEvents().isEmpty());
+        Assert.assertEquals(0, ts.getCompletions());
         
         ts.requestMore(2);
         
diff --git a/src/test/java/rx/observers/SerializedObserverTest.java b/src/test/java/rx/observers/SerializedObserverTest.java
index a814162695..775017b1dd 100644
--- a/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/src/test/java/rx/observers/SerializedObserverTest.java
@@ -792,7 +792,7 @@ protected void captureMaxThreads() {
     @Test
     public void testSerializeNull() {
         final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>();
-        TestObserver<Integer> to = new TestObserver<Integer>() {
+        TestSubscriber<Integer> to = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
                 if (t != null && t == 0) {
@@ -812,7 +812,7 @@ public void onNext(Integer t) {
     
     @Test
     public void testSerializeAllowsOnError() {
-        TestObserver<Integer> to = new TestObserver<Integer>() {
+        TestSubscriber<Integer> to = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
                 throw new TestException();
@@ -834,7 +834,7 @@ public void onNext(Integer t) {
     @Test
     public void testSerializeReentrantNullAndComplete() {
         final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>();
-        TestObserver<Integer> to = new TestObserver<Integer>() {
+        TestSubscriber<Integer> to = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
                 serial.get().onCompleted();
@@ -853,13 +853,13 @@ public void onNext(Integer t) {
         
         assertEquals(1, to.getOnErrorEvents().size());
         assertTrue(to.getOnErrorEvents().get(0) instanceof TestException);
-        assertTrue(to.getOnCompletedEvents().isEmpty());
+        assertEquals(0, to.getCompletions());
     }
     
     @Test
     public void testSerializeReentrantNullAndError() {
         final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>();
-        TestObserver<Integer> to = new TestObserver<Integer>() {
+        TestSubscriber<Integer> to = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
                 serial.get().onError(new RuntimeException());
@@ -878,13 +878,13 @@ public void onNext(Integer t) {
         
         assertEquals(1, to.getOnErrorEvents().size());
         assertTrue(to.getOnErrorEvents().get(0) instanceof TestException);
-        assertTrue(to.getOnCompletedEvents().isEmpty());
+        assertEquals(0, to.getCompletions());
     }
     
     @Test
     public void testSerializeDrainPhaseThrows() {
         final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>();
-        TestObserver<Integer> to = new TestObserver<Integer>() {
+        TestSubscriber<Integer> to = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
                 if (t != null && t == 0) {
diff --git a/src/test/java/rx/observers/TestObserverTest.java b/src/test/java/rx/observers/TestObserverTest.java
index 117455294f..f1b26f1e56 100644
--- a/src/test/java/rx/observers/TestObserverTest.java
+++ b/src/test/java/rx/observers/TestObserverTest.java
@@ -30,6 +30,7 @@
 import rx.exceptions.TestException;
 import rx.subjects.PublishSubject;
 
+@Deprecated
 public class TestObserverTest {
 
     @Rule
diff --git a/src/test/java/rx/observers/TestSubscriberTest.java b/src/test/java/rx/observers/TestSubscriberTest.java
index 6cee089f41..776f48367c 100644
--- a/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/src/test/java/rx/observers/TestSubscriberTest.java
@@ -179,11 +179,12 @@ public void testNullDelegate3() {
     
     @Test
     public void testDelegate1() {
-        TestObserver<Integer> to = new TestObserver<Integer>();
+        @SuppressWarnings("unchecked")
+        Observer<Integer> to = mock(Observer.class);
         TestSubscriber<Integer> ts = TestSubscriber.create(to);
         ts.onCompleted();
         
-        to.assertTerminalEvent();
+        verify(to).onCompleted();
     }
     
     @Test
@@ -562,11 +563,21 @@ public void testValueCount() {
     
     @Test(timeout = 1000)
     public void testOnCompletedCrashCountsDownLatch() {
-        TestObserver<Integer> to = new TestObserver<Integer>() {
+        Observer<Integer> to = new Observer<Integer>() {
             @Override
             public void onCompleted() {
                 throw new TestException();
             }
+
+            @Override
+            public void onError(Throwable e) {
+                
+            }
+
+            @Override
+            public void onNext(Integer t) {
+                
+            }
         };
         TestSubscriber<Integer> ts = TestSubscriber.create(to);
         
@@ -581,11 +592,21 @@ public void onCompleted() {
     
     @Test(timeout = 1000)
     public void testOnErrorCrashCountsDownLatch() {
-        TestObserver<Integer> to = new TestObserver<Integer>() {
+        Observer<Integer> to = new Observer<Integer>() {
             @Override
             public void onError(Throwable e) {
                 throw new TestException();
             }
+
+            @Override
+            public void onCompleted() {
+                
+            }
+
+            @Override
+            public void onNext(Integer t) {
+                
+            }
         };
         TestSubscriber<Integer> ts = TestSubscriber.create(to);
         
@@ -713,4 +734,42 @@ public void assertionFailureShowsMultipleCompletions() {
         }
     }
 
+    @Test
+    public void completionCount() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+
+        Assert.assertEquals(0, ts.getCompletions());
+
+        ts.onCompleted();
+        
+        Assert.assertEquals(1, ts.getCompletions());
+
+        ts.onCompleted();
+        
+        Assert.assertEquals(2, ts.getCompletions());
+    }
+    
+    @Test
+    public void awaitValueCount() throws Exception {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(1, 5).delay(100, TimeUnit.MILLISECONDS)
+        .subscribe(ts);
+        
+        Assert.assertTrue(ts.awaitValueCount(2, 5, TimeUnit.SECONDS));
+        
+        Assert.assertEquals(1, ts.getOnNextEvents().get(0).intValue());
+        Assert.assertEquals(2, ts.getOnNextEvents().get(1).intValue());
+    }
+    
+    @Test
+    public void awaitValueCountFails() throws Exception {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(1, 2).delay(100, TimeUnit.MILLISECONDS)
+        .subscribe(ts);
+        
+        Assert.assertFalse(ts.awaitValueCount(5, 1, TimeUnit.SECONDS));
+        
+    }
 }

From 829a0eda6647b4b64b53918110c2b5d5c3b2f1ec Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 22 Jun 2016 14:20:06 +0200
Subject: [PATCH 070/263] 1.x: ignore .pmd file in root directory (#4065)

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index fb5b67685f..383e959c61 100644
--- a/.gitignore
+++ b/.gitignore
@@ -69,3 +69,6 @@ bin/
 # Scala build
 *.cache
 /.nb-gradle/private/
+
+# PMD local rules
+.pmd
\ No newline at end of file

From a077f9ba1d7fb7d1e12686df17a077a5ba6aff9e Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Wed, 22 Jun 2016 14:34:35 +0200
Subject: [PATCH 071/263] 1.x: Ignore local.properties file (#4066)

---
 .gitignore | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 383e959c61..67413e11a7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -71,4 +71,7 @@ bin/
 /.nb-gradle/private/
 
 # PMD local rules
-.pmd
\ No newline at end of file
+.pmd
+
+# IntelliJ / Android Studio related files
+local.properties

From 9dd61b6f7079061a084652372d6b6ab7cf00edbe Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 22 Jun 2016 15:29:26 +0200
Subject: [PATCH 072/263] 1.x: scan & reduce give javadoc about unsharing the
 initialValue (#4063)

---
 src/main/java/rx/Observable.java | 38 ++++++++++++++++++++++++++++----
 1 file changed, 34 insertions(+), 4 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 53d14c4cfd..603e68d9e2 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -7201,8 +7201,8 @@ public final Observable<T> rebatchRequests(int n) {
      * that does a similar operation on lists.
      * <dl>
      *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure because by intent it will receive all values and reduce
-     *      them to a single {@code onNext}.</dd>
+     *  <dd>The operator honors backpressure of its downstream consumer and consumes the
+     *  upstream source in unbounded mode.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code reduce} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -7238,10 +7238,24 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
      * This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate,"
      * "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code inject} method
      * that does a similar operation on lists.
+     * <p>
+     * Note that the {@code initialValue} is shared among all subscribers to the resulting Observable
+     * and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer
+     * the application of this operator via {@link #defer(Func0)}:
+     * <pre><code>
+     * Observable&lt;T> source = ...
+     * Observable.defer(() -> source.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)));
+     * 
+     * // alternatively, by using compose to stay fluent
+     * 
+     * source.compose(o ->
+     *     Observable.defer(() -> o.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)))
+     * );
+     * </code></pre>
      * <dl>
      *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure because by intent it will receive all values and reduce
-     *      them to a single {@code onNext}.</dd>
+     *  <dd>The operator honors backpressure of its downstream consumer and consumes the
+     *  upstream source in unbounded mode.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code reduce} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8167,7 +8181,23 @@ public final Observable<T> scan(Func2<T, T, T> accumulator) {
      * <p>
      * Note that the Observable that results from this method will emit {@code initialValue} as its first
      * emitted item.
+     * <p>
+     * Note that the {@code initialValue} is shared among all subscribers to the resulting Observable
+     * and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer
+     * the application of this operator via {@link #defer(Func0)}:
+     * <pre><code>
+     * Observable&lt;T> source = ...
+     * Observable.defer(() -> source.scan(new ArrayList&lt;>(), (list, item) -> list.add(item)));
+     * 
+     * // alternatively, by using compose to stay fluent
+     * 
+     * source.compose(o ->
+     *     Observable.defer(() -> o.scan(new ArrayList&lt;>(), (list, item) -> list.add(item)))
+     * );
+     * </code></pre>
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code scan} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>

From d477f9c392d90960671dc883679f2ebeaed86acb Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 22 Jun 2016 15:37:34 +0200
Subject: [PATCH 073/263] 1.x: add package-info.java to the public packages
 (#4062)

* 1.x: add package-info.java to the public packages

* Adjust descriptions
---
 .../java/rx/annotations/package-info.java     | 20 +++++++++++++++++
 src/main/java/rx/exceptions/package-info.java | 21 ++++++++++++++++++
 src/main/java/rx/functions/package-info.java  | 21 ++++++++++++++++++
 .../java/rx/observables/package-info.java     | 21 ++++++++++++++++++
 src/main/java/rx/observers/package-info.java  | 21 ++++++++++++++++++
 src/main/java/rx/package-info.java            |  3 ++-
 src/main/java/rx/plugins/package-info.java    | 21 ++++++++++++++++++
 src/main/java/rx/schedulers/package-info.java |  3 ++-
 src/main/java/rx/singles/package-info.java    | 20 +++++++++++++++++
 src/main/java/rx/subjects/package-info.java   | 21 ++++++++++++++++++
 .../java/rx/subscriptions/package-info.java   | 22 +++++++++++++++++++
 11 files changed, 192 insertions(+), 2 deletions(-)
 create mode 100644 src/main/java/rx/annotations/package-info.java
 create mode 100644 src/main/java/rx/exceptions/package-info.java
 create mode 100644 src/main/java/rx/functions/package-info.java
 create mode 100644 src/main/java/rx/observables/package-info.java
 create mode 100644 src/main/java/rx/observers/package-info.java
 create mode 100644 src/main/java/rx/plugins/package-info.java
 create mode 100644 src/main/java/rx/singles/package-info.java
 create mode 100644 src/main/java/rx/subjects/package-info.java
 create mode 100644 src/main/java/rx/subscriptions/package-info.java

diff --git a/src/main/java/rx/annotations/package-info.java b/src/main/java/rx/annotations/package-info.java
new file mode 100644
index 0000000000..2dce85c83c
--- /dev/null
+++ b/src/main/java/rx/annotations/package-info.java
@@ -0,0 +1,20 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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.
+ */
+
+/**
+ * Annotations for indicating experimental and beta operators, classes, methods, types or fields.
+ */
+package rx.annotations;
\ No newline at end of file
diff --git a/src/main/java/rx/exceptions/package-info.java b/src/main/java/rx/exceptions/package-info.java
new file mode 100644
index 0000000000..3cd8ac94dc
--- /dev/null
+++ b/src/main/java/rx/exceptions/package-info.java
@@ -0,0 +1,21 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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.
+ */
+
+/**
+ * Exception handling utilities, safe subscriber exception classes, 
+ * lifecycle exception classes.
+ */
+package rx.exceptions;
\ No newline at end of file
diff --git a/src/main/java/rx/functions/package-info.java b/src/main/java/rx/functions/package-info.java
new file mode 100644
index 0000000000..11c97eaf2e
--- /dev/null
+++ b/src/main/java/rx/functions/package-info.java
@@ -0,0 +1,21 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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.
+ */
+
+/**
+ * Functional interfaces of functions and actions of arity 0 to 9 and related
+ * utility classes.
+ */
+package rx.functions;
\ No newline at end of file
diff --git a/src/main/java/rx/observables/package-info.java b/src/main/java/rx/observables/package-info.java
new file mode 100644
index 0000000000..d099621e48
--- /dev/null
+++ b/src/main/java/rx/observables/package-info.java
@@ -0,0 +1,21 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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.
+ */
+
+/**
+ * Classes extending the Observable base reactive class, synchronous and
+ * asynchronous event generators.
+ */
+package rx.observables;
\ No newline at end of file
diff --git a/src/main/java/rx/observers/package-info.java b/src/main/java/rx/observers/package-info.java
new file mode 100644
index 0000000000..c7648ee8c1
--- /dev/null
+++ b/src/main/java/rx/observers/package-info.java
@@ -0,0 +1,21 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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.
+ */
+
+/**
+ * Default wrappers and implementations for the base reactive consumer classes and interfaces;
+ * utility classes for creating them from callbacks.
+ */
+package rx.observers;
\ No newline at end of file
diff --git a/src/main/java/rx/package-info.java b/src/main/java/rx/package-info.java
index fb3dc1f459..cae651eab2 100644
--- a/src/main/java/rx/package-info.java
+++ b/src/main/java/rx/package-info.java
@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 /**
- * <p>Rx Observables</p>
+ * Base reactive classes: Observable, Single and Completable; base reactive consumers;
+ * other common base interfaces.
  * 
  * <p>A library that enables subscribing to and composing asynchronous events and
  * callbacks.</p>
diff --git a/src/main/java/rx/plugins/package-info.java b/src/main/java/rx/plugins/package-info.java
new file mode 100644
index 0000000000..a222aa51b7
--- /dev/null
+++ b/src/main/java/rx/plugins/package-info.java
@@ -0,0 +1,21 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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.
+ */
+
+/**
+ * Callback types and a central plugin handler class to hook into the lifecycle
+ * of the base reactive types and schedulers.
+ */
+package rx.plugins;
\ No newline at end of file
diff --git a/src/main/java/rx/schedulers/package-info.java b/src/main/java/rx/schedulers/package-info.java
index 82eaa0abb9..7dc59c5083 100644
--- a/src/main/java/rx/schedulers/package-info.java
+++ b/src/main/java/rx/schedulers/package-info.java
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 /**
- * Rx Schedulers
+ * Scheduler implementations, value+time record classes and the standard factory class to 
+ * return standard RxJava schedulers or wrap any Executor-based (thread pool) instances.
  */
 package rx.schedulers;
\ No newline at end of file
diff --git a/src/main/java/rx/singles/package-info.java b/src/main/java/rx/singles/package-info.java
new file mode 100644
index 0000000000..c6d2f61004
--- /dev/null
+++ b/src/main/java/rx/singles/package-info.java
@@ -0,0 +1,20 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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.
+ */
+
+/**
+ * Classes extending the Single base reactive class.
+ */
+package rx.singles;
\ No newline at end of file
diff --git a/src/main/java/rx/subjects/package-info.java b/src/main/java/rx/subjects/package-info.java
new file mode 100644
index 0000000000..7460145054
--- /dev/null
+++ b/src/main/java/rx/subjects/package-info.java
@@ -0,0 +1,21 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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.
+ */
+
+/**
+ * Classes extending the Observable base reactive class and implementing
+ * the Observer interface at the same time (aka hot Observables).
+ */
+package rx.subjects;
\ No newline at end of file
diff --git a/src/main/java/rx/subscriptions/package-info.java b/src/main/java/rx/subscriptions/package-info.java
new file mode 100644
index 0000000000..636b3acabb
--- /dev/null
+++ b/src/main/java/rx/subscriptions/package-info.java
@@ -0,0 +1,22 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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.
+ */
+
+/**
+ * Default implementations for Subscription-based resource management
+ * (Subscription container types) and utility classes to construct
+ * Subscriptions from callbacks and other types.
+ */
+package rx.subscriptions;
\ No newline at end of file

From 3650215055ef9cd9852eb60b4ead1071cc1afc63 Mon Sep 17 00:00:00 2001
From: max <maxthomas@users.noreply.github.com>
Date: Wed, 22 Jun 2016 15:52:29 -0400
Subject: [PATCH 074/263] Fix an issue with README.md where the links to the
 Java annotations were pointing to master, which yields a 404 error. (#4077)

---
 README.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index ab237a8358..da3619c8df 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ Version 1.x is now a stable API and will be supported for several years.
 
 Minor 1.x increments (such as 1.1, 1.2, etc) will occur when non-trivial new functionality is added or significant enhancements or bug fixes occur that may have behavioral changes that may affect some edge cases (such as dependence on behavior resulting from a bug). An example of an enhancement that would classify as this is adding reactive pull backpressure support to an operator that previously did not support it. This should be backwards compatible but does behave differently.
 
-Patch 1.x.y increments (such as 1.0.0 -> 1.0.1, 1.3.1 -> 1.3.2, etc) will occur for bug fixes and trivial functionality (like adding a method overload). New functionality marked with an [`@Beta`][beta source link] or [`@Experimental`][experimental source link] annotation can also be added in patch releases to allow rapid exploration and iteration of unstable new functionality. 
+Patch 1.x.y increments (such as 1.0.0 -> 1.0.1, 1.3.1 -> 1.3.2, etc) will occur for bug fixes and trivial functionality (like adding a method overload). New functionality marked with an [`@Beta`][beta source link] or [`@Experimental`][experimental source link] annotation can also be added in patch releases to allow rapid exploration and iteration of unstable new functionality.
 
 #### @Beta
 
@@ -42,7 +42,7 @@ APIs marked with the [`@Beta`][beta source link] annotation at the class or meth
 
 #### @Experimental
 
-APIs marked with the [`@Experimental`][experimental source link] annotation at the class or method level will almost certainly change. They can be modified in any way, or even removed in any major, minor or, patch release. You should not use or rely on them in any production code. They are purely to allow broad testing and feedback. 
+APIs marked with the [`@Experimental`][experimental source link] annotation at the class or method level will almost certainly change. They can be modified in any way, or even removed in any major, minor or, patch release. You should not use or rely on them in any production code. They are purely to allow broad testing and feedback.
 
 #### @Deprecated
 
@@ -50,7 +50,7 @@ APIs marked with the `@Deprecated` annotation at the class or method level will
 
 #### rx.internal.*
 
-All code inside the `rx.internal.*` packages is considered private API and should not be relied upon at all. It can change at any time. 
+All code inside the `rx.internal.*` packages is considered private API and should not be relied upon at all. It can change at any time.
 
 ## Full Documentation
 
@@ -110,7 +110,7 @@ Futher details on building can be found on the [Getting Started](https://github.
 
 For bugs, questions and discussions please use the [Github Issues](https://github.com/ReactiveX/RxJava/issues).
 
- 
+
 ## LICENSE
 
 Copyright 2013 Netflix, Inc.
@@ -127,5 +127,5 @@ 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.
 
-[beta source link]: https://github.com/ReactiveX/RxJava/blob/master/src/main/java/rx/annotations/Beta.java
-[experimental source link]: https://github.com/ReactiveX/RxJava/blob/master/src/main/java/rx/annotations/Experimental.java
+[beta source link]: https://github.com/ReactiveX/RxJava/blob/1.x/src/main/java/rx/annotations/Beta.java
+[experimental source link]: https://github.com/ReactiveX/RxJava/blob/1.x/src/main/java/rx/annotations/Experimental.java

From 544690b4d45aedee8f0880f28442262faadc9f97 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 22 Jun 2016 22:42:51 +0200
Subject: [PATCH 075/263] 1.x: Add PMD code checking tool to the build process
 (#4068)

* 1.x: Run PMD, cat its result xml

* Next attempt

* Restore travis.yml

* Remove unnecessary task, fix nit
---
 build.gradle |  38 +++++++++
 pmd.xml      | 230 +++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 268 insertions(+)
 create mode 100644 pmd.xml

diff --git a/build.gradle b/build.gradle
index 1026fa9031..5b1a651f19 100644
--- a/build.gradle
+++ b/build.gradle
@@ -6,6 +6,7 @@ buildscript {
 description = 'RxJava: Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.'
 
 apply plugin: 'java'
+apply plugin: 'pmd'
 apply plugin: 'jacoco'
 apply plugin: 'nebula.rxjava-project'
 
@@ -60,3 +61,40 @@ jacocoTestReport {
 }
 
 build.dependsOn jacocoTestReport
+
+pmd {
+    toolVersion = '5.4.2'
+    ignoreFailures = true
+    sourceSets = [sourceSets.main]
+    ruleSets = []
+    ruleSetFiles = files('pmd.xml')
+
+}
+
+pmdMain {
+    reports {
+        html.enabled = true
+        xml.enabled = true
+    }
+}
+
+build.dependsOn pmdMain
+
+task pmdPrint(dependsOn: 'pmdMain') << {
+    File file = new File('build/reports/pmd/main.xml')
+    if (file.exists()) {
+    
+        println("Listing first 100 PMD violations")
+        
+        file.eachLine { line, count ->
+            if (count <= 100) {
+               println(line)
+            }
+        }
+    
+    } else {
+        println("PMD file not found.")
+    }
+}
+
+build.dependsOn pmdPrint
\ No newline at end of file
diff --git a/pmd.xml b/pmd.xml
new file mode 100644
index 0000000000..e6fbccdd95
--- /dev/null
+++ b/pmd.xml
@@ -0,0 +1,230 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ruleset xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         name="pmd"
+         xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd">
+   <description>RxJava PMD ruleset</description>
+   <rule ref="rulesets/java/design.xml/AbstractClassWithoutAbstractMethod"/>
+   <rule ref="rulesets/java/design.xml/AbstractClassWithoutAnyMethod"/>
+   <rule ref="rulesets/java/design.xml/AccessorClassGeneration"/>
+   <rule ref="rulesets/java/optimizations.xml/AddEmptyString"/>
+   <rule ref="rulesets/java/strings.xml/AppendCharacterWithChar"/>
+   <rule ref="rulesets/java/design.xml/AssignmentToNonFinalStatic"/>
+   <rule ref="rulesets/java/controversial.xml/AvoidAccessibilityAlteration"/>
+   <rule ref="rulesets/java/optimizations.xml/AvoidArrayLoops"/>
+   <rule ref="rulesets/java/migrating.xml/AvoidAssertAsIdentifier"/>
+   <rule ref="rulesets/java/basic.xml/AvoidBranchingStatementAsLastInLoop"/>
+   <rule ref="rulesets/java/finalizers.xml/AvoidCallingFinalize"/>
+   <rule ref="rulesets/java/strictexception.xml/AvoidCatchingGenericException"/>
+   <rule ref="rulesets/java/strictexception.xml/AvoidCatchingNPE"/>
+   <rule ref="rulesets/java/design.xml/AvoidConstantsInterface"/>
+   <rule ref="rulesets/java/basic.xml/AvoidDecimalLiteralsInBigDecimalConstructor"/>
+   <rule ref="rulesets/java/naming.xml/AvoidDollarSigns"/>
+   <rule ref="rulesets/java/migrating.xml/AvoidEnumAsIdentifier"/>
+   <rule ref="rulesets/java/controversial.xml/AvoidFinalLocalVariable"/>
+   <rule ref="rulesets/java/design.xml/AvoidInstanceofChecksInCatchClause"/>
+   <rule ref="rulesets/java/strictexception.xml/AvoidLosingExceptionInformation"/>
+   <rule ref="rulesets/java/basic.xml/AvoidMultipleUnaryOperators"/>
+   <rule ref="rulesets/java/controversial.xml/AvoidPrefixingMethodParameters"/>
+   <rule ref="rulesets/java/logging-java.xml/AvoidPrintStackTrace"/>
+   <rule ref="rulesets/java/design.xml/AvoidProtectedFieldInFinalClass"/>
+   <rule ref="rulesets/java/design.xml/AvoidProtectedMethodInFinalClassNotExtending"/>
+   <rule ref="rulesets/java/strictexception.xml/AvoidRethrowingException"/>
+   <rule ref="rulesets/java/strings.xml/AvoidStringBufferField"/>
+   <rule ref="rulesets/java/design.xml/AvoidSynchronizedAtMethodLevel"/>
+   <rule ref="rulesets/java/basic.xml/AvoidThreadGroup"/>
+   <rule ref="rulesets/java/strictexception.xml/AvoidThrowingNewInstanceOfSameException"/>
+   <rule ref="rulesets/java/strictexception.xml/AvoidThrowingRawExceptionTypes"/>
+   <rule ref="rulesets/java/basic.xml/AvoidUsingHardCodedIP"/>
+   <rule ref="rulesets/java/controversial.xml/AvoidUsingNativeCode"/>
+   <rule ref="rulesets/java/basic.xml/AvoidUsingOctalValues"/>
+   <rule ref="rulesets/java/controversial.xml/AvoidUsingShortType"/>
+   <rule ref="rulesets/java/design.xml/BadComparison"/>
+   <rule ref="rulesets/java/basic.xml/BigIntegerInstantiation"/>
+   <rule ref="rulesets/java/naming.xml/BooleanGetMethodName"/>
+   <rule ref="rulesets/java/basic.xml/BooleanInstantiation"/>
+   <rule ref="rulesets/java/basic.xml/BrokenNullCheck"/>
+   <rule ref="rulesets/java/migrating.xml/ByteInstantiation"/>
+   <rule ref="rulesets/java/android.xml/CallSuperFirst"/>
+   <rule ref="rulesets/java/android.xml/CallSuperLast"/>
+   <rule ref="rulesets/java/basic.xml/CheckResultSet"/>
+   <rule ref="rulesets/java/basic.xml/CheckSkipResult"/>
+   <rule ref="rulesets/java/basic.xml/ClassCastExceptionWithToArray"/>
+   <rule ref="rulesets/java/naming.xml/ClassNamingConventions"/>
+   <rule ref="rulesets/java/design.xml/ClassWithOnlyPrivateConstructorsShouldBeFinal"/>
+   <rule ref="rulesets/java/clone.xml/CloneMethodMustImplementCloneable"/>
+   <rule ref="rulesets/java/clone.xml/CloneThrowsCloneNotSupportedException"/>
+   <rule ref="rulesets/java/design.xml/CloseResource"/>
+   <rule ref="rulesets/java/comments.xml/CommentContent"/>
+   <rule ref="rulesets/java/strings.xml/ConsecutiveAppendsShouldReuse"/>
+   <rule ref="rulesets/java/strings.xml/ConsecutiveLiteralAppends"/>
+   <rule ref="rulesets/java/design.xml/ConstructorCallsOverridableMethod"/>
+   <rule ref="rulesets/java/coupling.xml/CouplingBetweenObjects"/>
+   <rule ref="rulesets/java/design.xml/DefaultLabelNotLastInSwitchStmt"/>
+   <rule ref="rulesets/java/controversial.xml/DoNotCallGarbageCollectionExplicitly"/>
+   <rule ref="rulesets/java/j2ee.xml/DoNotCallSystemExit"/>
+   <rule ref="rulesets/java/strictexception.xml/DoNotExtendJavaLangError"/>
+   <rule ref="rulesets/java/android.xml/DoNotHardCodeSDCard"/>
+   <rule ref="rulesets/java/strictexception.xml/DoNotThrowExceptionInFinally"/>
+   <rule ref="rulesets/java/basic.xml/DontCallThreadRun"/>
+   <rule ref="rulesets/java/imports.xml/DontImportJavaLang"/>
+   <rule ref="rulesets/java/basic.xml/DontUseFloatTypeForLoopIndices"/>
+   <rule ref="rulesets/java/basic.xml/DoubleCheckedLocking"/>
+   <rule ref="rulesets/java/imports.xml/DuplicateImports"/>
+   <rule ref="rulesets/java/empty.xml/EmptyCatchBlock"/>
+   <rule ref="rulesets/java/finalizers.xml/EmptyFinalizer"/>
+   <rule ref="rulesets/java/empty.xml/EmptyFinallyBlock"/>
+   <rule ref="rulesets/java/empty.xml/EmptyInitializer"/>
+   <rule ref="rulesets/java/empty.xml/EmptyStatementBlock"/>
+   <rule ref="rulesets/java/empty.xml/EmptyStatementNotInLoop"/>
+   <rule ref="rulesets/java/empty.xml/EmptyStaticInitializer"/>
+   <rule ref="rulesets/java/empty.xml/EmptySwitchStatements"/>
+   <rule ref="rulesets/java/empty.xml/EmptySynchronizedBlock"/>
+   <rule ref="rulesets/java/empty.xml/EmptyTryBlock"/>
+   <rule ref="rulesets/java/empty.xml/EmptyWhileStmt"/>
+   <rule ref="rulesets/java/design.xml/EqualsNull"/>
+   <rule ref="rulesets/java/strictexception.xml/ExceptionAsFlowControl"/>
+   <rule ref="rulesets/java/coupling.xml/ExcessiveImports"/>
+   <rule ref="rulesets/java/basic.xml/ExtendsObject"/>
+   <rule ref="rulesets/java/design.xml/FieldDeclarationsShouldBeAtStartOfClass"/>
+   <rule ref="rulesets/java/design.xml/FinalFieldCouldBeStatic"/>
+   <rule ref="rulesets/java/finalizers.xml/FinalizeDoesNotCallSuperFinalize"/>
+   <rule ref="rulesets/java/finalizers.xml/FinalizeOnlyCallsSuperFinalize"/>
+   <rule ref="rulesets/java/finalizers.xml/FinalizeOverloaded"/>
+   <rule ref="rulesets/java/finalizers.xml/FinalizeShouldBeProtected"/>
+   <rule ref="rulesets/java/basic.xml/ForLoopShouldBeWhileLoop"/>
+   <rule ref="rulesets/java/braces.xml/ForLoopsMustUseBraces"/>
+   <rule ref="rulesets/java/logging-jakarta-commons.xml/GuardDebugLogging"/>
+   <rule ref="rulesets/java/logging-jakarta-commons.xml/GuardLogStatement"/>
+   <rule ref="rulesets/java/logging-java.xml/GuardLogStatementJavaUtil"/>
+   <rule ref="rulesets/java/design.xml/IdempotentOperations"/>
+   <rule ref="rulesets/java/braces.xml/IfElseStmtsMustUseBraces"/>
+   <rule ref="rulesets/java/braces.xml/IfStmtsMustUseBraces"/>
+   <rule ref="rulesets/java/design.xml/ImmutableField"/>
+   <rule ref="rulesets/java/imports.xml/ImportFromSamePackage"/>
+   <rule ref="rulesets/java/strings.xml/InefficientEmptyStringCheck"/>
+   <rule ref="rulesets/java/strings.xml/InefficientStringBuffering"/>
+   <rule ref="rulesets/java/design.xml/InstantiationToGetClass"/>
+   <rule ref="rulesets/java/strings.xml/InsufficientStringBufferDeclaration"/>
+   <rule ref="rulesets/java/migrating.xml/IntegerInstantiation"/>
+   <rule ref="rulesets/java/migrating.xml/JUnit4SuitesShouldUseSuiteAnnotation"/>
+   <rule ref="rulesets/java/migrating.xml/JUnit4TestShouldUseAfterAnnotation"/>
+   <rule ref="rulesets/java/migrating.xml/JUnit4TestShouldUseBeforeAnnotation"/>
+   <rule ref="rulesets/java/migrating.xml/JUnit4TestShouldUseTestAnnotation"/>
+   <rule ref="rulesets/java/junit.xml/JUnitAssertionsShouldIncludeMessage"/>
+   <rule ref="rulesets/java/junit.xml/JUnitSpelling"/>
+   <rule ref="rulesets/java/junit.xml/JUnitStaticSuite"/>
+   <rule ref="rulesets/java/junit.xml/JUnitTestContainsTooManyAsserts"/>
+   <rule ref="rulesets/java/junit.xml/JUnitTestsShouldIncludeAssert"/>
+   <rule ref="rulesets/java/migrating.xml/JUnitUseExpected"/>
+   <rule ref="rulesets/java/basic.xml/JumbledIncrementer"/>
+   <rule ref="rulesets/java/j2ee.xml/LocalHomeNamingConvention"/>
+   <rule ref="rulesets/java/j2ee.xml/LocalInterfaceSessionNamingConvention"/>
+   <rule ref="rulesets/java/logging-java.xml/LoggerIsNotStaticFinal"/>
+   <rule ref="rulesets/java/design.xml/LogicInversion"/>
+   <rule ref="rulesets/java/migrating.xml/LongInstantiation"/>
+   <rule ref="rulesets/java/coupling.xml/LooseCoupling"/>
+   <rule ref="rulesets/java/j2ee.xml/MDBAndSessionBeanNamingConvention"/>
+   <rule ref="rulesets/java/naming.xml/MethodNamingConventions"/>
+   <rule ref="rulesets/java/sunsecure.xml/MethodReturnsInternalArray"/>
+   <rule ref="rulesets/java/naming.xml/MethodWithSameNameAsEnclosingClass"/>
+   <rule ref="rulesets/java/naming.xml/MisleadingVariableName"/>
+   <rule ref="rulesets/java/basic.xml/MisplacedNullCheck"/>
+   <rule ref="rulesets/java/design.xml/MissingBreakInSwitch"/>
+   <rule ref="rulesets/java/javabeans.xml/MissingSerialVersionUID"/>
+   <rule ref="rulesets/java/design.xml/MissingStaticMethodInNonInstantiatableClass"/>
+   <rule ref="rulesets/java/logging-java.xml/MoreThanOneLogger"/>
+   <rule ref="rulesets/java/codesize.xml/NcssConstructorCount"/>
+   <rule ref="rulesets/java/codesize.xml/NcssMethodCount"/>
+   <rule ref="rulesets/java/codesize.xml/NcssTypeCount"/>
+   <rule ref="rulesets/java/naming.xml/NoPackage"/>
+   <rule ref="rulesets/java/design.xml/NonCaseLabelInSwitchStatement"/>
+   <rule ref="rulesets/java/design.xml/NonStaticInitializer"/>
+   <rule ref="rulesets/java/design.xml/NonThreadSafeSingleton"/>
+   <rule ref="rulesets/java/controversial.xml/OneDeclarationPerLine"/>
+   <rule ref="rulesets/java/design.xml/OptimizableToArrayCall"/>
+   <rule ref="rulesets/java/basic.xml/OverrideBothEqualsAndHashcode"/>
+   <rule ref="rulesets/java/naming.xml/PackageCase"/>
+   <rule ref="rulesets/java/design.xml/PositionLiteralsFirstInCaseInsensitiveComparisons"/>
+   <rule ref="rulesets/java/design.xml/PositionLiteralsFirstInComparisons"/>
+   <rule ref="rulesets/java/optimizations.xml/PrematureDeclaration"/>
+   <rule ref="rulesets/java/design.xml/PreserveStackTrace"/>
+   <rule ref="rulesets/java/clone.xml/ProperCloneImplementation"/>
+   <rule ref="rulesets/java/logging-jakarta-commons.xml/ProperLogger"/>
+   <rule ref="rulesets/java/optimizations.xml/RedundantFieldInitializer"/>
+   <rule ref="rulesets/java/j2ee.xml/RemoteInterfaceNamingConvention"/>
+   <rule ref="rulesets/java/j2ee.xml/RemoteSessionInterfaceNamingConvention"/>
+   <rule ref="rulesets/java/migrating.xml/ReplaceEnumerationWithIterator"/>
+   <rule ref="rulesets/java/migrating.xml/ReplaceHashtableWithMap"/>
+   <rule ref="rulesets/java/migrating.xml/ReplaceVectorWithList"/>
+   <rule ref="rulesets/java/design.xml/ReturnEmptyArrayRatherThanNull"/>
+   <rule ref="rulesets/java/basic.xml/ReturnFromFinallyBlock"/>
+   <rule ref="rulesets/java/migrating.xml/ShortInstantiation"/>
+   <rule ref="rulesets/java/naming.xml/ShortMethodName"/>
+   <rule ref="rulesets/java/strictexception.xml/SignatureDeclareThrowsException"/>
+   <rule ref="rulesets/java/design.xml/SimpleDateFormatNeedsLocale"/>
+   <rule ref="rulesets/java/junit.xml/SimplifyBooleanAssertion"/>
+   <rule ref="rulesets/java/design.xml/SimplifyBooleanExpressions"/>
+   <rule ref="rulesets/java/design.xml/SimplifyBooleanReturns"/>
+   <rule ref="rulesets/java/design.xml/SimplifyConditional"/>
+   <rule ref="rulesets/java/optimizations.xml/SimplifyStartsWith"/>
+   <rule ref="rulesets/java/design.xml/SingularField"/>
+   <rule ref="rulesets/java/j2ee.xml/StaticEJBFieldShouldBeFinal"/>
+   <rule ref="rulesets/java/strings.xml/StringBufferInstantiationWithChar"/>
+   <rule ref="rulesets/java/strings.xml/StringInstantiation"/>
+   <rule ref="rulesets/java/strings.xml/StringToString"/>
+   <rule ref="rulesets/java/naming.xml/SuspiciousConstantFieldName"/>
+   <rule ref="rulesets/java/naming.xml/SuspiciousEqualsMethodName"/>
+   <rule ref="rulesets/java/naming.xml/SuspiciousHashcodeMethodName"/>
+   <rule ref="rulesets/java/controversial.xml/SuspiciousOctalEscape"/>
+   <rule ref="rulesets/java/design.xml/SwitchDensity"/>
+   <rule ref="rulesets/java/design.xml/SwitchStmtsShouldHaveDefault"/>
+   <rule ref="rulesets/java/logging-java.xml/SystemPrintln"/>
+   <rule ref="rulesets/java/junit.xml/TestClassWithoutTestCases"/>
+   <rule ref="rulesets/java/design.xml/TooFewBranchesForASwitchStatement"/>
+   <rule ref="rulesets/java/imports.xml/TooManyStaticImports"/>
+   <rule ref="rulesets/java/design.xml/UncommentedEmptyConstructor"/>
+   <rule ref="rulesets/java/design.xml/UncommentedEmptyMethodBody"/>
+   <rule ref="rulesets/java/basic.xml/UnconditionalIfStatement"/>
+   <rule ref="rulesets/java/junit.xml/UnnecessaryBooleanAssertion"/>
+   <rule ref="rulesets/java/strings.xml/UnnecessaryCaseChange"/>
+   <rule ref="rulesets/java/controversial.xml/UnnecessaryConstructor"/>
+   <rule ref="rulesets/java/unnecessary.xml/UnnecessaryConversionTemporary"/>
+   <rule ref="rulesets/java/unnecessary.xml/UnnecessaryFinalModifier"/>
+   <rule ref="rulesets/java/imports.xml/UnnecessaryFullyQualifiedName"/>
+   <rule ref="rulesets/java/design.xml/UnnecessaryLocalBeforeReturn"/>
+   <rule ref="rulesets/java/controversial.xml/UnnecessaryParentheses"/>
+   <rule ref="rulesets/java/unnecessary.xml/UnnecessaryReturn"/>
+   <rule ref="rulesets/java/optimizations.xml/UnnecessaryWrapperObjectCreation"/>
+   <rule ref="rulesets/java/design.xml/UnsynchronizedStaticDateFormatter"/>
+   <rule ref="rulesets/java/unusedcode.xml/UnusedFormalParameter"/>
+   <rule ref="rulesets/java/imports.xml/UnusedImports"/>
+   <rule ref="rulesets/java/unusedcode.xml/UnusedLocalVariable"/>
+   <rule ref="rulesets/java/unusedcode.xml/UnusedModifier"/>
+   <rule ref="rulesets/java/unnecessary.xml/UnusedNullCheckInEquals"/>
+   <rule ref="rulesets/java/unusedcode.xml/UnusedPrivateField"/>
+   <rule ref="rulesets/java/unusedcode.xml/UnusedPrivateMethod"/>
+   <rule ref="rulesets/java/optimizations.xml/UseArrayListInsteadOfVector"/>
+   <rule ref="rulesets/java/optimizations.xml/UseArraysAsList"/>
+   <rule ref="rulesets/java/junit.xml/UseAssertEqualsInsteadOfAssertTrue"/>
+   <rule ref="rulesets/java/junit.xml/UseAssertNullInsteadOfAssertTrue"/>
+   <rule ref="rulesets/java/junit.xml/UseAssertSameInsteadOfAssertTrue"/>
+   <rule ref="rulesets/java/junit.xml/UseAssertTrueInsteadOfAssertEquals"/>
+   <rule ref="rulesets/java/design.xml/UseCollectionIsEmpty"/>
+   <rule ref="rulesets/java/controversial.xml/UseConcurrentHashMap"/>
+   <rule ref="rulesets/java/logging-jakarta-commons.xml/UseCorrectExceptionLogging"/>
+   <rule ref="rulesets/java/strings.xml/UseEqualsToCompareStrings"/>
+   <rule ref="rulesets/java/strings.xml/UseIndexOfChar"/>
+   <rule ref="rulesets/java/design.xml/UseLocaleWithCaseConversions"/>
+   <rule ref="rulesets/java/design.xml/UseNotifyAllInsteadOfNotify"/>
+   <rule ref="rulesets/java/controversial.xml/UseObjectForClearerAPI"/>
+   <rule ref="rulesets/java/j2ee.xml/UseProperClassLoader"/>
+   <rule ref="rulesets/java/optimizations.xml/UseStringBufferForStringAppends"/>
+   <rule ref="rulesets/java/strings.xml/UseStringBufferLength"/>
+   <rule ref="rulesets/java/design.xml/UseUtilityClass"/>
+   <rule ref="rulesets/java/unnecessary.xml/UselessOperationOnImmutable"/>
+   <rule ref="rulesets/java/unnecessary.xml/UselessOverridingMethod"/>
+   <rule ref="rulesets/java/strings.xml/UselessStringValueOf"/>
+   <rule ref="rulesets/java/naming.xml/VariableNamingConventions"/>
+   <rule ref="rulesets/java/braces.xml/WhileLoopsMustUseBraces"/>
+</ruleset>
\ No newline at end of file

From 47477cfc6410c0df62af24aefba995d8993286c8 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 23 Jun 2016 09:05:25 +0200
Subject: [PATCH 076/263] 1.x: new hook management proposal (#4007)

* 1.x: new hook management proposal

* Add missing javadoc
---
 src/main/java/rx/Completable.java             |  54 +-
 src/main/java/rx/Observable.java              |  28 +-
 src/main/java/rx/Single.java                  |  44 +-
 .../AssemblyStackTraceException.java          |  52 +
 .../java/rx/exceptions/OnErrorThrowable.java  |   1 +
 .../CompletableOnSubscribeConcat.java         |   6 +-
 .../CompletableOnSubscribeMerge.java          |  12 +-
 .../CompletableOnSubscribeMergeArray.java     |   6 +-
 .../CompletableOnSubscribeMergeIterable.java  |  10 +-
 .../CompletableOnSubscribeTimeout.java        |   4 +-
 .../operators/OnSubscribeCombineLatest.java   |   4 +-
 .../operators/OnSubscribeConcatMap.java       |   4 +-
 .../OnSubscribeDelaySubscriptionOther.java    |   2 +-
 .../internal/operators/OnSubscribeLift.java   |   4 +-
 .../operators/OnSubscribeOnAssembly.java      | 128 +++
 .../OnSubscribeOnAssemblyCompletable.java     |  78 ++
 .../OnSubscribeOnAssemblySingle.java          |  74 ++
 .../operators/OperatorDoAfterTerminate.java   |   4 +-
 .../internal/operators/OperatorGroupBy.java   |   4 +-
 .../operators/OperatorMaterialize.java        |   8 +-
 .../internal/operators/OperatorObserveOn.java |   6 +-
 .../OperatorOnErrorResumeNextViaFunction.java |   4 +-
 .../rx/internal/operators/OperatorSwitch.java |   4 +-
 ...ngleOnSubscribeDelaySubscriptionOther.java |   9 +-
 .../operators/SingleOnSubscribeUsing.java     |   6 +-
 .../internal/operators/SingleOperatorZip.java |  14 +-
 .../schedulers/ExecutorScheduler.java         |   6 +-
 .../internal/schedulers/NewThreadWorker.java  |  12 +-
 .../internal/schedulers/ScheduledAction.java  |   4 +-
 .../rx/internal/util/RxJavaPluginUtils.java   |   4 +-
 .../util/ScalarSynchronousObservable.java     |  10 +-
 .../java/rx/observables/AsyncOnSubscribe.java |   4 +-
 .../java/rx/observables/SyncOnSubscribe.java  |  17 +-
 .../RxJavaCompletableExecutionHook.java       |   4 +
 .../java/rx/plugins/RxJavaErrorHandler.java   |   3 +-
 src/main/java/rx/plugins/RxJavaHooks.java     | 944 ++++++++++++++++++
 .../RxJavaObservableExecutionHook.java        |   5 +
 src/main/java/rx/plugins/RxJavaPlugins.java   |   6 +
 .../java/rx/plugins/RxJavaSchedulersHook.java |   1 +
 .../rx/plugins/RxJavaSingleExecutionHook.java |   5 +
 src/main/java/rx/schedulers/Schedulers.java   |  10 +-
 src/test/java/rx/CompletableTest.java         |  39 +-
 src/test/java/rx/SingleTest.java              |  67 +-
 .../util/ScalarSynchronousObservableTest.java |  31 +-
 .../java/rx/observers/SafeSubscriberTest.java |  12 +-
 src/test/java/rx/plugins/RxJavaHooksTest.java | 165 +++
 .../java/rx/plugins/RxJavaPluginsTest.java    |   1 +
 .../rx/schedulers/ResetSchedulersTest.java    |   1 +
 48 files changed, 1696 insertions(+), 225 deletions(-)
 create mode 100644 src/main/java/rx/exceptions/AssemblyStackTraceException.java
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java
 create mode 100644 src/main/java/rx/plugins/RxJavaHooks.java
 create mode 100644 src/test/java/rx/plugins/RxJavaHooksTest.java

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 23c9dff907..e5f7c4a068 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -38,12 +38,6 @@
  */
 @Experimental
 public class Completable {
-    /** The error handler instance. */
-    static final RxJavaErrorHandler ERROR_HANDLER = RxJavaPlugins.getInstance().getErrorHandler();
-    
-    /** The completable hook. */
-    static RxJavaCompletableExecutionHook HOOK = RxJavaPlugins.getInstance().getCompletableExecutionHook();
-
     /**
      * Callback used for building deferred computations that takes a CompletableSubscriber.
      */
@@ -146,7 +140,7 @@ public void onError(Throwable e) {
                             set.unsubscribe();
                             s.onError(e);
                         } else {
-                            ERROR_HANDLER.handleError(e);
+                            RxJavaHooks.onError(e);
                         }
                     }
 
@@ -167,7 +161,7 @@ public void onSubscribe(Subscription d) {
                             set.unsubscribe();
                             s.onError(npe);
                         } else {
-                            ERROR_HANDLER.handleError(npe);
+                            RxJavaHooks.onError(npe);
                         }
                         return;
                     }
@@ -215,7 +209,7 @@ public void onError(Throwable e) {
                             set.unsubscribe();
                             s.onError(e);
                         } else {
-                            ERROR_HANDLER.handleError(e);
+                            RxJavaHooks.onError(e);
                         }
                     }
 
@@ -256,7 +250,7 @@ public void onSubscribe(Subscription d) {
                             set.unsubscribe();
                             s.onError(e);
                         } else {
-                            ERROR_HANDLER.handleError(e);
+                            RxJavaHooks.onError(e);
                         }
                         return;
                     }
@@ -283,7 +277,7 @@ public void onSubscribe(Subscription d) {
                             set.unsubscribe();
                             s.onError(e);
                         } else {
-                            ERROR_HANDLER.handleError(e);
+                            RxJavaHooks.onError(e);
                         }
                         return;
                     }
@@ -294,7 +288,7 @@ public void onSubscribe(Subscription d) {
                             set.unsubscribe();
                             s.onError(npe);
                         } else {
-                            ERROR_HANDLER.handleError(npe);
+                            RxJavaHooks.onError(npe);
                         }
                         return;
                     }
@@ -386,7 +380,7 @@ public static Completable create(CompletableOnSubscribe onSubscribe) {
         } catch (NullPointerException ex) {
             throw ex;
         } catch (Throwable ex) {
-            ERROR_HANDLER.handleError(ex);
+            RxJavaHooks.onError(ex);
             throw toNpe(ex);
         } 
     }
@@ -912,7 +906,7 @@ void dispose() {
                             try {
                                 disposer.call(resource);
                             } catch (Throwable ex) {
-                                ERROR_HANDLER.handleError(ex);
+                                RxJavaHooks.onError(ex);
                             }
                         }
                     }
@@ -980,7 +974,7 @@ public void call() {
      * not null (not verified)
      */
     protected Completable(CompletableOnSubscribe onSubscribe) {
-        this.onSubscribe = HOOK.onCreate(onSubscribe);
+        this.onSubscribe = RxJavaHooks.onCreate(onSubscribe);
     }
     
     /**
@@ -1338,7 +1332,7 @@ public void onCompleted() {
                         try {
                             onAfterComplete.call();
                         } catch (Throwable e) {
-                            ERROR_HANDLER.handleError(e);
+                            RxJavaHooks.onError(e);
                         }
                     }
 
@@ -1371,7 +1365,7 @@ public void call() {
                                 try {
                                     onUnsubscribe.call();
                                 } catch (Throwable e) {
-                                    ERROR_HANDLER.handleError(e);
+                                    RxJavaHooks.onError(e);
                                 }
                                 d.unsubscribe();
                             }
@@ -1552,7 +1546,7 @@ public final Completable lift(final CompletableOperator onLift) {
             @Override
             public void call(CompletableSubscriber s) {
                 try {
-                    CompletableOperator onLiftDecorated = HOOK.onLift(onLift);
+                    CompletableOperator onLiftDecorated = RxJavaHooks.onCompletableLift(onLift);
                     CompletableSubscriber sw = onLiftDecorated.call(s);
                     
                     unsafeSubscribe(sw);
@@ -1879,7 +1873,7 @@ public void onCompleted() {
             
             @Override
             public void onError(Throwable e) {
-                ERROR_HANDLER.handleError(e);
+                RxJavaHooks.onError(e);
                 mad.unsubscribe();
                 deliverUncaughtException(e);
             }
@@ -1896,7 +1890,7 @@ public void onSubscribe(Subscription d) {
      * Subscribes to this Completable and calls the given Action0 when this Completable
      * completes normally.
      * <p>
-     * If this Completable emits an error, it is sent to ERROR_HANDLER.handleError and gets swallowed.
+     * If this Completable emits an error, it is sent to RxJavaHooks.onError and gets swallowed.
      * @param onComplete the runnable called when this Completable completes normally
      * @return the Subscription that allows cancelling the subscription
      */
@@ -1913,7 +1907,7 @@ public void onCompleted() {
                     try {
                         onComplete.call();
                     } catch (Throwable e) {
-                        ERROR_HANDLER.handleError(e);
+                        RxJavaHooks.onError(e);
                         deliverUncaughtException(e);
                     } finally {
                         mad.unsubscribe();
@@ -1923,7 +1917,7 @@ public void onCompleted() {
             
             @Override
             public void onError(Throwable e) {
-                ERROR_HANDLER.handleError(e);
+                RxJavaHooks.onError(e);
                 mad.unsubscribe();
                 deliverUncaughtException(e);
             }
@@ -1972,7 +1966,7 @@ public void onError(Throwable e) {
                     done = true;
                     callOnError(e);
                 } else {
-                    ERROR_HANDLER.handleError(e);
+                    RxJavaHooks.onError(e);
                     deliverUncaughtException(e);
                 }
             }
@@ -1982,7 +1976,7 @@ void callOnError(Throwable e) {
                     onError.call(e);
                 } catch (Throwable ex) {
                     e = new CompositeException(Arrays.asList(e, ex));
-                    ERROR_HANDLER.handleError(e);
+                    RxJavaHooks.onError(e);
                     deliverUncaughtException(e);
                 } finally {
                     mad.unsubscribe();
@@ -2011,15 +2005,15 @@ private static void deliverUncaughtException(Throwable e) {
     public final void unsafeSubscribe(CompletableSubscriber s) {
         requireNonNull(s);
         try {
-            CompletableOnSubscribe onSubscribeDecorated = HOOK.onSubscribeStart(this, this.onSubscribe);
+            CompletableOnSubscribe onSubscribeDecorated = RxJavaHooks.onCompletableStart(this, this.onSubscribe);
             
             onSubscribeDecorated.call(s);
         } catch (NullPointerException ex) {
             throw ex;
         } catch (Throwable ex) {
             Exceptions.throwIfFatal(ex);
-            ex = HOOK.onSubscribeError(ex);
-            ERROR_HANDLER.handleError(ex);
+            ex = RxJavaHooks.onCompletableError(ex);
+            RxJavaHooks.onError(ex);
             throw toNpe(ex);
         }
     }
@@ -2077,13 +2071,13 @@ public void onSubscribe(Subscription d) {
                     s.add(d);
                 }
             });
-            RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeReturn(s);
+            RxJavaHooks.onObservableReturn(s);
         } catch (NullPointerException ex) {
             throw ex;
         } catch (Throwable ex) {
             Exceptions.throwIfFatal(ex);
-            ex = HOOK.onSubscribeError(ex);
-            ERROR_HANDLER.handleError(ex);
+            ex = RxJavaHooks.onObservableError(ex);
+            RxJavaHooks.onError(ex);
             throw toNpe(ex);
         }
     }
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 603e68d9e2..4507c4480f 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -59,8 +59,6 @@ protected Observable(OnSubscribe<T> f) {
         this.onSubscribe = f;
     }
 
-    static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
-
     /**
      * Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to
      * it.
@@ -91,7 +89,7 @@ protected Observable(OnSubscribe<T> f) {
      * @see <a href="http://reactivex.io/documentation/operators/create.html">ReactiveX operators documentation: Create</a>
      */
     public static <T> Observable<T> create(OnSubscribe<T> f) {
-        return new Observable<T>(hook.onCreate(f));
+        return new Observable<T>(RxJavaHooks.onCreate(f));
     }
 
     /**
@@ -133,7 +131,7 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
      */
     @Beta
     public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe) {
-        return new Observable<T>(hook.onCreate(syncOnSubscribe));
+        return create((OnSubscribe<T>)syncOnSubscribe);
     }
 
     /**
@@ -174,7 +172,7 @@ public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe)
      */
     @Experimental
     public static <S, T> Observable<T> create(AsyncOnSubscribe<S, T> asyncOnSubscribe) {
-        return new Observable<T>(hook.onCreate(asyncOnSubscribe));
+        return create((OnSubscribe<T>)asyncOnSubscribe);
     }
 
     /**
@@ -250,7 +248,7 @@ public void call(Subscriber<? super T> subscriber) {
      * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Implementing-Your-Own-Operators">RxJava wiki: Implementing Your Own Operators</a>
      */
     public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
-        return new Observable<R>(new OnSubscribeLift<T, R>(onSubscribe, operator));
+        return create(new OnSubscribeLift<T, R>(onSubscribe, operator));
     }
     
     /**
@@ -9001,21 +8999,21 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
             // new Subscriber so onStart it
             subscriber.onStart();
             // allow the hook to intercept and/or decorate
-            hook.onSubscribeStart(this, onSubscribe).call(subscriber);
-            return hook.onSubscribeReturn(subscriber);
+            RxJavaHooks.onObservableStart(this, onSubscribe).call(subscriber);
+            return RxJavaHooks.onObservableReturn(subscriber);
         } catch (Throwable e) {
             // special handling for certain Throwable/Error/Exception types
             Exceptions.throwIfFatal(e);
             // if an unhandled error occurs executing the onSubscribe we will propagate it
             try {
-                subscriber.onError(hook.onSubscribeError(e));
+                subscriber.onError(RxJavaHooks.onObservableError(e));
             } catch (Throwable e2) {
                 Exceptions.throwIfFatal(e2);
                 // if this happens it means the onError itself failed (perhaps an invalid function implementation)
                 // so we are unable to propagate the error correctly and will just throw
                 RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
                 // TODO could the hook be the cause of the error in the on error handling.
-                hook.onSubscribeError(r);
+                RxJavaHooks.onObservableError(r);
                 // TODO why aren't we throwing the hook's return value.
                 throw r;
             }
@@ -9094,25 +9092,25 @@ static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T
         // add a significant depth to already huge call stacks.
         try {
             // allow the hook to intercept and/or decorate
-            hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
-            return hook.onSubscribeReturn(subscriber);
+            RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
+            return RxJavaHooks.onObservableReturn(subscriber);
         } catch (Throwable e) {
             // special handling for certain Throwable/Error/Exception types
             Exceptions.throwIfFatal(e);
             // in case the subscriber can't listen to exceptions anymore
             if (subscriber.isUnsubscribed()) {
-                RxJavaPluginUtils.handleException(hook.onSubscribeError(e));
+                RxJavaPluginUtils.handleException(RxJavaHooks.onObservableError(e));
             } else {
                 // if an unhandled error occurs executing the onSubscribe we will propagate it
                 try {
-                    subscriber.onError(hook.onSubscribeError(e));
+                    subscriber.onError(RxJavaHooks.onObservableError(e));
                 } catch (Throwable e2) {
                     Exceptions.throwIfFatal(e2);
                     // if this happens it means the onError itself failed (perhaps an invalid function implementation)
                     // so we are unable to propagate the error correctly and will just throw
                     RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
                     // TODO could the hook be the cause of the error in the on error handling.
-                    hook.onSubscribeError(r);
+                    RxJavaHooks.onObservableError(r);
                     // TODO why aren't we throwing the hook's return value.
                     throw r;
                 }
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 2c6bd61646..183f869fd0 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -16,19 +16,14 @@
 import java.util.concurrent.*;
 
 import rx.Observable.Operator;
-import rx.annotations.Beta;
-import rx.annotations.Experimental;
-import rx.exceptions.Exceptions;
-import rx.exceptions.OnErrorNotImplementedException;
+import rx.annotations.*;
+import rx.exceptions.*;
 import rx.functions.*;
 import rx.internal.operators.*;
 import rx.internal.producers.SingleDelayedProducer;
-import rx.internal.util.ScalarSynchronousSingle;
-import rx.internal.util.UtilityFunctions;
-import rx.observers.SafeSubscriber;
-import rx.observers.SerializedSubscriber;
-import rx.plugins.RxJavaPlugins;
-import rx.plugins.RxJavaSingleExecutionHook;
+import rx.internal.util.*;
+import rx.observers.*;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.Schedulers;
 import rx.singles.BlockingSingle;
 import rx.subscriptions.Subscriptions;
@@ -69,7 +64,8 @@ public class Single<T> {
      *            {@code OnExecute} to be executed when {@code execute(SingleSubscriber)} or
      *            {@code subscribe(Subscriber)} is called
      */
-    protected Single(final OnSubscribe<T> f) {
+    protected Single(OnSubscribe<T> f) {
+        final OnSubscribe<T> g = RxJavaHooks.onCreate(f);
         // bridge between OnSubscribe (which all Operators and Observables use) and OnExecute (for Single)
         this.onSubscribe = new Observable.OnSubscribe<T>() {
 
@@ -91,18 +87,16 @@ public void onError(Throwable error) {
 
                 };
                 child.add(ss);
-                f.call(ss);
+                g.call(ss);
             }
 
         };
     }
 
     private Single(final Observable.OnSubscribe<T> f) {
-        this.onSubscribe = f;
+        this.onSubscribe = RxJavaHooks.onCreate(f);
     }
 
-    static RxJavaSingleExecutionHook hook = RxJavaPlugins.getInstance().getSingleExecutionHook();
-
     /**
      * Returns a Single that will execute the specified function when a {@link SingleSubscriber} executes it or
      * a {@link Subscriber} subscribes to it.
@@ -130,7 +124,7 @@ private Single(final Observable.OnSubscribe<T> f) {
      * @see <a href="http://reactivex.io/documentation/operators/create.html">ReactiveX operators documentation: Create</a>
      */
     public static <T> Single<T> create(OnSubscribe<T> f) {
-        return new Single<T>(hook.onCreate(f));
+        return new Single<T>(f);
     }
 
     /**
@@ -170,7 +164,7 @@ public final <R> Single<R> lift(final Operator<? extends R, ? super T> lift) {
             @Override
             public void call(Subscriber<? super R> o) {
                 try {
-                    final Subscriber<? super T> st = hook.onLift(lift).call(o);
+                    final Subscriber<? super T> st = RxJavaHooks.onSingleLift(lift).call(o);
                     try {
                         // new Subscriber created and being subscribed with so 'onStart' it
                         st.onStart();
@@ -1709,21 +1703,21 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
         try {
             // new Subscriber so onStart it
             subscriber.onStart();
-            hook.onSubscribeStart(this, onSubscribe).call(subscriber);
-            return hook.onSubscribeReturn(subscriber);
+            RxJavaHooks.onSingleStart(this, onSubscribe).call(subscriber);
+            return RxJavaHooks.onSingleReturn(subscriber);
         } catch (Throwable e) {
             // special handling for certain Throwable/Error/Exception types
             Exceptions.throwIfFatal(e);
             // if an unhandled error occurs executing the onSubscribe we will propagate it
             try {
-                subscriber.onError(hook.onSubscribeError(e));
+                subscriber.onError(RxJavaHooks.onSingleError(e));
             } catch (Throwable e2) {
                 Exceptions.throwIfFatal(e2);
                 // if this happens it means the onError itself failed (perhaps an invalid function implementation)
                 // so we are unable to propagate the error correctly and will just throw
                 RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
                 // TODO could the hook be the cause of the error in the on error handling.
-                hook.onSubscribeError(r);
+                RxJavaHooks.onSingleError(r);
                 // TODO why aren't we throwing the hook's return value.
                 throw r;
             }
@@ -1819,21 +1813,21 @@ public final Subscription subscribe(Subscriber<? super T> subscriber) {
         // The code below is exactly the same an unsafeSubscribe but not used because it would add a significant depth to already huge call stacks.
         try {
             // allow the hook to intercept and/or decorate
-            hook.onSubscribeStart(this, onSubscribe).call(subscriber);
-            return hook.onSubscribeReturn(subscriber);
+            RxJavaHooks.onSingleStart(this, onSubscribe).call(subscriber);
+            return RxJavaHooks.onSingleReturn(subscriber);
         } catch (Throwable e) {
             // special handling for certain Throwable/Error/Exception types
             Exceptions.throwIfFatal(e);
             // if an unhandled error occurs executing the onSubscribe we will propagate it
             try {
-                subscriber.onError(hook.onSubscribeError(e));
+                subscriber.onError(RxJavaHooks.onSingleError(e));
             } catch (Throwable e2) {
                 Exceptions.throwIfFatal(e2);
                 // if this happens it means the onError itself failed (perhaps an invalid function implementation)
                 // so we are unable to propagate the error correctly and will just throw
                 RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
                 // TODO could the hook be the cause of the error in the on error handling.
-                hook.onSubscribeError(r);
+                RxJavaHooks.onSingleError(r);
                 // TODO why aren't we throwing the hook's return value.
                 throw r;
             }
diff --git a/src/main/java/rx/exceptions/AssemblyStackTraceException.java b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
new file mode 100644
index 0000000000..ee6a8be6a9
--- /dev/null
+++ b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
@@ -0,0 +1,52 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.exceptions;
+
+import rx.annotations.Experimental;
+
+/**
+ * A RuntimeException that is stackless but holds onto a textual
+ * stacktrace from tracking the assembly location of operators.
+ */
+@Experimental
+public final class AssemblyStackTraceException extends RuntimeException {
+
+    /** */
+    private static final long serialVersionUID = 2038859767182585852L;
+
+    /**
+     * Constructs an AssemblyStackTraceException with the given message and
+     * a cause.
+     * @param message the message
+     * @param cause the cause
+     */
+    public AssemblyStackTraceException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Constructs an AssemblyStackTraceException with the given message.
+     * @param message the message
+     */
+    public AssemblyStackTraceException(String message) {
+        super(message);
+    }
+
+    @Override
+    public synchronized Throwable fillInStackTrace() {
+        return this;
+    }
+}
diff --git a/src/main/java/rx/exceptions/OnErrorThrowable.java b/src/main/java/rx/exceptions/OnErrorThrowable.java
index 52ce45ed2a..2ef465141b 100644
--- a/src/main/java/rx/exceptions/OnErrorThrowable.java
+++ b/src/main/java/rx/exceptions/OnErrorThrowable.java
@@ -191,6 +191,7 @@ static String renderValue(Object value){
                 return ((Enum<?>) value).name();
             }
 
+            @SuppressWarnings("deprecation")
             String pluggedRendering = RxJavaPlugins.getInstance().getErrorHandler().handleOnNextValueRendering(value);
             if (pluggedRendering != null) {
                 return pluggedRendering;
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
index bccea15cc4..96cccc23f7 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
@@ -22,7 +22,7 @@
 import rx.Completable.*;
 import rx.exceptions.MissingBackpressureException;
 import rx.internal.util.unsafe.SpscArrayQueue;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.SerialSubscription;
 
 public final class CompletableOnSubscribeConcat implements CompletableOnSubscribe {
@@ -87,7 +87,7 @@ public void onError(Throwable t) {
                 actual.onError(t);
                 return;
             }
-            RxJavaPlugins.getInstance().getErrorHandler().handleError(t);
+            RxJavaHooks.onError(t);
         }
         
         @Override
@@ -125,7 +125,7 @@ void next() {
                     }
                     return;
                 }
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(new IllegalStateException("Queue is empty?!"));
+                RxJavaHooks.onError(new IllegalStateException("Queue is empty?!"));
                 return;
             }
             
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
index 059e193da7..48dce53c9c 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
@@ -22,9 +22,9 @@
 
 import rx.*;
 import rx.Completable.*;
-import rx.exceptions.CompositeException;
 import rx.Observable;
-import rx.plugins.RxJavaPlugins;
+import rx.exceptions.CompositeException;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
 public final class CompletableOnSubscribeMerge implements CompletableOnSubscribe {
@@ -110,7 +110,7 @@ public void onSubscribe(Subscription d) {
                 @Override
                 public void onError(Throwable e) {
                     if (innerDone) {
-                        RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                        RxJavaHooks.onError(e);
                         return;
                     }
                     innerDone = true;
@@ -145,7 +145,7 @@ public void onCompleted() {
         @Override
         public void onError(Throwable t) {
             if (done) {
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(t);
+                RxJavaHooks.onError(t);
                 return;
             }
             getOrCreateErrors().offer(t);
@@ -172,7 +172,7 @@ void terminate() {
                     if (once.compareAndSet(false, true)) {
                         actual.onError(e);
                     } else {
-                        RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                        RxJavaHooks.onError(e);
                     }
                 }
             } else
@@ -183,7 +183,7 @@ void terminate() {
                     if (once.compareAndSet(false, true)) {
                         actual.onError(e);
                     } else {
-                        RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                        RxJavaHooks.onError(e);
                     }
                 }
             }
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
index f78c960430..d80f50abf6 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
@@ -20,7 +20,7 @@
 
 import rx.*;
 import rx.Completable.*;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
 public final class CompletableOnSubscribeMergeArray implements CompletableOnSubscribe {
@@ -50,7 +50,7 @@ public void call(final CompletableSubscriber s) {
                     s.onError(npe);
                     return;
                 } else {
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(npe);
+                    RxJavaHooks.onError(npe);
                 }
             }
             
@@ -66,7 +66,7 @@ public void onError(Throwable e) {
                     if (once.compareAndSet(false, true)) {
                         s.onError(e);
                     } else {
-                        RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                        RxJavaHooks.onError(e);
                     }
                 }
 
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
index e13670cd20..fed111a6c7 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
@@ -21,7 +21,7 @@
 
 import rx.*;
 import rx.Completable.*;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
 public final class CompletableOnSubscribeMergeIterable implements CompletableOnSubscribe {
@@ -66,7 +66,7 @@ public void call(final CompletableSubscriber s) {
                 if (once.compareAndSet(false, true)) {
                     s.onError(e);
                 } else {
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                    RxJavaHooks.onError(e);
                 }
                 return;
             }
@@ -88,7 +88,7 @@ public void call(final CompletableSubscriber s) {
                 if (once.compareAndSet(false, true)) {
                     s.onError(e);
                 } else {
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                    RxJavaHooks.onError(e);
                 }
                 return;
             }
@@ -103,7 +103,7 @@ public void call(final CompletableSubscriber s) {
                 if (once.compareAndSet(false, true)) {
                     s.onError(npe);
                 } else {
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(npe);
+                    RxJavaHooks.onError(npe);
                 }
                 return;
             }
@@ -122,7 +122,7 @@ public void onError(Throwable e) {
                     if (once.compareAndSet(false, true)) {
                         s.onError(e);
                     } else {
-                        RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                        RxJavaHooks.onError(e);
                     }
                 }
 
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
index b62c62274d..672cfad61b 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
@@ -22,7 +22,7 @@
 import rx.*;
 import rx.Completable.*;
 import rx.functions.Action0;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
 public final class CompletableOnSubscribeTimeout implements CompletableOnSubscribe {
@@ -98,7 +98,7 @@ public void onError(Throwable e) {
                     set.unsubscribe();
                     s.onError(e);
                 } else {
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                    RxJavaHooks.onError(e);
                 }
             }
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
index 10b4b582cd..e9dac2d026 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
@@ -23,7 +23,7 @@
 import rx.functions.FuncN;
 import rx.internal.util.RxRingBuffer;
 import rx.internal.util.atomic.SpscLinkedArrayQueue;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 
 public final class OnSubscribeCombineLatest<T, R> implements OnSubscribe<R> {
     final Observable<? extends T>[] sources;
@@ -386,7 +386,7 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable t) {
             if (done) {
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(t);
+                RxJavaHooks.onError(t);
                 return;
             }
             parent.onError(t);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java b/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java
index c2799df758..fba34e2f6b 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java
@@ -28,7 +28,7 @@
 import rx.internal.util.atomic.SpscAtomicArrayQueue;
 import rx.internal.util.unsafe.*;
 import rx.observers.SerializedSubscriber;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.SerialSubscription;
 
 /**
@@ -210,7 +210,7 @@ void innerCompleted(long produced) {
         }
         
         void pluginError(Throwable e) {
-            RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+            RxJavaHooks.onError(e);
         }
         
         void drain() {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java
index dc3146d7e6..d25d940d61 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java
@@ -56,7 +56,7 @@ public void onNext(U t) {
             @Override
             public void onError(Throwable e) {
                 if (done) {
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                    RxJavaHooks.onError(e);
                     return;
                 }
                 done = true;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeLift.java b/src/main/java/rx/internal/operators/OnSubscribeLift.java
index ba6210f38b..65f6f20d14 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeLift.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeLift.java
@@ -29,8 +29,6 @@
  */
 public final class OnSubscribeLift<T, R> implements OnSubscribe<R> {
     
-    static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
-
     final OnSubscribe<T> parent;
 
     final Operator<? extends R, ? super T> operator;
@@ -43,7 +41,7 @@ public OnSubscribeLift(OnSubscribe<T> parent, Operator<? extends R, ? super T> o
     @Override
     public void call(Subscriber<? super R> o) {
         try {
-            Subscriber<? super T> st = hook.onLift(operator).call(o);
+            Subscriber<? super T> st = RxJavaHooks.onObservableLift(operator).call(o);
             try {
                 // new Subscriber created and being subscribed with so 'onStart' it
                 st.onStart();
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
new file mode 100644
index 0000000000..fd338c1ece
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
@@ -0,0 +1,128 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.exceptions.AssemblyStackTraceException;
+
+/**
+ * Captures the current stack when it is instantiated, makes
+ * it available through a field and attaches it to all
+ * passing exception.
+ *
+ * @param <T> the value type
+ */
+public final class OnSubscribeOnAssembly<T> implements OnSubscribe<T> {
+
+    final OnSubscribe<T> source;
+    
+    final String stacktrace;
+
+    /**
+     * If set to true, the creation of PublisherOnAssembly will capture the raw
+     * stacktrace instead of the sanitized version.
+     */
+    public static volatile boolean fullStackTrace;
+    
+    public OnSubscribeOnAssembly(OnSubscribe<T> source) {
+        this.source = source;
+        this.stacktrace = createStacktrace();
+    }
+    
+    static String createStacktrace() {
+        StackTraceElement[] stes = Thread.currentThread().getStackTrace();
+
+        StringBuilder sb = new StringBuilder("Assembly trace:");
+        
+        for (StackTraceElement e : stes) {
+            String row = e.toString();
+            if (!fullStackTrace) {
+                if (e.getLineNumber() <= 1) {
+                    continue;
+                }
+                if (row.contains("RxJavaHooks.")) {
+                    continue;
+                }
+                if (row.contains("OnSubscribeOnAssembly")) {
+                    continue;
+                }
+                if (row.contains(".junit.runner")) {
+                    continue;
+                }
+                if (row.contains(".junit4.runner")) {
+                    continue;
+                }
+                if (row.contains(".junit.internal")) {
+                    continue;
+                }
+                if (row.contains("sun.reflect")) {
+                    continue;
+                }
+                if (row.contains("java.lang.Thread.")) {
+                    continue;
+                }
+                if (row.contains("ThreadPoolExecutor")) {
+                    continue;
+                }
+                if (row.contains("org.apache.catalina.")) {
+                    continue;
+                }
+                if (row.contains("org.apache.tomcat.")) {
+                    continue;
+                }
+            }
+            sb.append("\n at ").append(row);
+        }
+        
+        return sb.append("\nOriginal exception:").toString();
+    }
+
+    @Override
+    public void call(Subscriber<? super T> t) {
+        source.call(new OnAssemblySubscriber<T>(t, stacktrace));
+    }
+    
+    static final class OnAssemblySubscriber<T> extends Subscriber<T> {
+
+        final Subscriber<? super T> actual;
+        
+        final String stacktrace;
+        
+        public OnAssemblySubscriber(Subscriber<? super T> actual, String stacktrace) {
+            super(actual);
+            this.actual = actual;
+            this.stacktrace = stacktrace;
+        }
+
+        @Override
+        public void onCompleted() {
+            actual.onCompleted();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            e = new AssemblyStackTraceException(stacktrace, e);
+            actual.onError(e);
+        }
+
+        @Override
+        public void onNext(T t) {
+            actual.onNext(t);
+        }
+        
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
new file mode 100644
index 0000000000..da5a144045
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
@@ -0,0 +1,78 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.Completable.CompletableSubscriber;
+import rx.exceptions.AssemblyStackTraceException;
+
+/**
+ * Captures the current stack when it is instantiated, makes
+ * it available through a field and attaches it to all
+ * passing exception.
+ *
+ * @param <T> the value type
+ */
+public final class OnSubscribeOnAssemblyCompletable<T> implements Completable.CompletableOnSubscribe {
+
+    final Completable.CompletableOnSubscribe source;
+    
+    final String stacktrace;
+
+    /**
+     * If set to true, the creation of PublisherOnAssembly will capture the raw
+     * stacktrace instead of the sanitized version.
+     */
+    public static volatile boolean fullStackTrace;
+    
+    public OnSubscribeOnAssemblyCompletable(Completable.CompletableOnSubscribe source) {
+        this.source = source;
+        this.stacktrace = OnSubscribeOnAssembly.createStacktrace();
+    }
+    
+    @Override
+    public void call(Completable.CompletableSubscriber t) {
+        source.call(new OnAssemblyCompletableSubscriber(t, stacktrace));
+    }
+    
+    static final class OnAssemblyCompletableSubscriber implements CompletableSubscriber {
+
+        final CompletableSubscriber actual;
+        
+        final String stacktrace;
+        
+        public OnAssemblyCompletableSubscriber(CompletableSubscriber actual, String stacktrace) {
+            this.actual = actual;
+            this.stacktrace = stacktrace;
+        }
+
+        @Override
+        public void onSubscribe(Subscription d) {
+            actual.onSubscribe(d);
+        }
+        
+        @Override
+        public void onCompleted() {
+            actual.onCompleted();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            e = new AssemblyStackTraceException(stacktrace, e);
+            actual.onError(e);
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java
new file mode 100644
index 0000000000..aeed623a7b
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java
@@ -0,0 +1,74 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.exceptions.AssemblyStackTraceException;
+
+/**
+ * Captures the current stack when it is instantiated, makes
+ * it available through a field and attaches it to all
+ * passing exception.
+ *
+ * @param <T> the value type
+ */
+public final class OnSubscribeOnAssemblySingle<T> implements Single.OnSubscribe<T> {
+
+    final Single.OnSubscribe<T> source;
+    
+    final String stacktrace;
+
+    /**
+     * If set to true, the creation of PublisherOnAssembly will capture the raw
+     * stacktrace instead of the sanitized version.
+     */
+    public static volatile boolean fullStackTrace;
+    
+    public OnSubscribeOnAssemblySingle(Single.OnSubscribe<T> source) {
+        this.source = source;
+        this.stacktrace = OnSubscribeOnAssembly.createStacktrace();
+    }
+    
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        source.call(new OnAssemblySingleSubscriber<T>(t, stacktrace));
+    }
+    
+    static final class OnAssemblySingleSubscriber<T> extends SingleSubscriber<T> {
+
+        final SingleSubscriber<? super T> actual;
+        
+        final String stacktrace;
+        
+        public OnAssemblySingleSubscriber(SingleSubscriber<? super T> actual, String stacktrace) {
+            this.actual = actual;
+            this.stacktrace = stacktrace;
+            actual.add(this);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            e = new AssemblyStackTraceException(stacktrace, e);
+            actual.onError(e);
+        }
+
+        @Override
+        public void onSuccess(T t) {
+            actual.onSuccess(t);
+        }
+        
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OperatorDoAfterTerminate.java b/src/main/java/rx/internal/operators/OperatorDoAfterTerminate.java
index 64afca478a..a3efa8f845 100644
--- a/src/main/java/rx/internal/operators/OperatorDoAfterTerminate.java
+++ b/src/main/java/rx/internal/operators/OperatorDoAfterTerminate.java
@@ -19,7 +19,7 @@
 import rx.Subscriber;
 import rx.exceptions.Exceptions;
 import rx.functions.Action0;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Registers an action to be called after an Observable invokes {@code onComplete} or {@code onError}.
@@ -73,7 +73,7 @@ void callAction() {
                     action.call();
                 } catch (Throwable ex) {
                     Exceptions.throwIfFatal(ex);
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(ex);
+                    RxJavaHooks.onError(ex);
                 }
             }
         };
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index bf474619bb..4ed1a504f3 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -25,7 +25,7 @@
 import rx.internal.producers.ProducerArbiter;
 import rx.internal.util.*;
 import rx.observables.GroupedObservable;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -196,7 +196,7 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable t) {
             if (done) {
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(t);
+                RxJavaHooks.onError(t);
                 return;
             }
             error = t;
diff --git a/src/main/java/rx/internal/operators/OperatorMaterialize.java b/src/main/java/rx/internal/operators/OperatorMaterialize.java
index 75700b8d11..4d01dadf39 100644
--- a/src/main/java/rx/internal/operators/OperatorMaterialize.java
+++ b/src/main/java/rx/internal/operators/OperatorMaterialize.java
@@ -17,11 +17,9 @@
 
 import java.util.concurrent.atomic.AtomicLong;
 
-import rx.Notification;
+import rx.*;
 import rx.Observable.Operator;
-import rx.Producer;
-import rx.Subscriber;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Turns all of the notifications from an Observable into {@code onNext} emissions, and marks
@@ -104,7 +102,7 @@ public void onCompleted() {
         @Override
         public void onError(Throwable e) {
             terminalNotification = Notification.createOnError(e);
-            RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+            RxJavaHooks.onError(e);
             drain();
         }
 
diff --git a/src/main/java/rx/internal/operators/OperatorObserveOn.java b/src/main/java/rx/internal/operators/OperatorObserveOn.java
index 10ad74e4e2..42fc5518ae 100644
--- a/src/main/java/rx/internal/operators/OperatorObserveOn.java
+++ b/src/main/java/rx/internal/operators/OperatorObserveOn.java
@@ -23,10 +23,10 @@
 import rx.exceptions.MissingBackpressureException;
 import rx.functions.Action0;
 import rx.internal.schedulers.*;
-import rx.internal.util.*;
+import rx.internal.util.RxRingBuffer;
 import rx.internal.util.atomic.SpscAtomicArrayQueue;
 import rx.internal.util.unsafe.*;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.Schedulers;
 
 /**
@@ -177,7 +177,7 @@ public void onCompleted() {
         @Override
         public void onError(final Throwable e) {
             if (isUnsubscribed() || finished) {
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                RxJavaHooks.onError(e);
                 return;
             }
             error = e;
diff --git a/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java b/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
index 7f5b22c0a2..d78b75ce57 100644
--- a/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
+++ b/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
@@ -20,7 +20,7 @@
 import rx.exceptions.Exceptions;
 import rx.functions.Func1;
 import rx.internal.producers.ProducerArbiter;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.SerialSubscription;
 
 /**
@@ -105,7 +105,7 @@ public void onCompleted() {
             public void onError(Throwable e) {
                 if (done) {
                     Exceptions.throwIfFatal(e);
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                    RxJavaHooks.onError(e);
                     return;
                 }
                 done = true;
diff --git a/src/main/java/rx/internal/operators/OperatorSwitch.java b/src/main/java/rx/internal/operators/OperatorSwitch.java
index bbbcd9879d..c76e3008c9 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitch.java
+++ b/src/main/java/rx/internal/operators/OperatorSwitch.java
@@ -25,7 +25,7 @@
 import rx.functions.Action0;
 import rx.internal.util.RxRingBuffer;
 import rx.internal.util.atomic.SpscLinkedArrayQueue;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.*;
 
 /**
@@ -238,7 +238,7 @@ void complete(long id) {
         }
 
         void pluginError(Throwable e) {
-            RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+            RxJavaHooks.onError(e);
         }
         
         void innerProducer(Producer p, long id) {
diff --git a/src/main/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOther.java b/src/main/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOther.java
index 41d0383ac9..92452706cb 100644
--- a/src/main/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOther.java
+++ b/src/main/java/rx/internal/operators/SingleOnSubscribeDelaySubscriptionOther.java
@@ -16,11 +16,8 @@
 
 package rx.internal.operators;
 
-import rx.Observable;
-import rx.Single;
-import rx.SingleSubscriber;
-import rx.Subscriber;
-import rx.plugins.RxJavaPlugins;
+import rx.*;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.SerialSubscription;
 
 /**
@@ -66,7 +63,7 @@ public void onNext(Object t) {
             @Override
             public void onError(Throwable e) {
                 if (done) {
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                    RxJavaHooks.onError(e);
                     return;
                 }
                 done = true;
diff --git a/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java b/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
index 54cdfe5c24..9d7319724c 100644
--- a/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
+++ b/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
@@ -21,7 +21,7 @@
 import rx.*;
 import rx.exceptions.*;
 import rx.functions.*;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Generates a resource, derives a Single from it and disposes that resource once the
@@ -91,7 +91,7 @@ public void onSuccess(T value) {
                         disposeAction.call(resource);
                     } catch (Throwable ex2) {
                         Exceptions.throwIfFatal(ex2);
-                        RxJavaPlugins.getInstance().getErrorHandler().handleError(ex2);
+                        RxJavaHooks.onError(ex2);
                     }
                 }
             }
@@ -125,7 +125,7 @@ void handleSubscriptionTimeError(SingleSubscriber<? super T> t, Resource resourc
                 disposeAction.call(resource);
             } catch (Throwable ex2) {
                 Exceptions.throwIfFatal(ex2);
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(ex2);
+                RxJavaHooks.onError(ex2);
             }
         }
     }
diff --git a/src/main/java/rx/internal/operators/SingleOperatorZip.java b/src/main/java/rx/internal/operators/SingleOperatorZip.java
index 7614a6a6c5..93afe523d3 100644
--- a/src/main/java/rx/internal/operators/SingleOperatorZip.java
+++ b/src/main/java/rx/internal/operators/SingleOperatorZip.java
@@ -16,17 +16,15 @@
 
 package rx.internal.operators;
 
-import rx.Single;
-import rx.SingleSubscriber;
+import java.util.NoSuchElementException;
+import java.util.concurrent.atomic.*;
+
+import rx.*;
 import rx.exceptions.Exceptions;
 import rx.functions.FuncN;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
-import java.util.NoSuchElementException;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-
 public class SingleOperatorZip {
 
     public static <T, R> Single<R> zip(final Single<? extends T>[] singles, final FuncN<? extends R> zipper) {
@@ -75,7 +73,7 @@ public void onError(Throwable error) {
                             if (once.compareAndSet(false, true)) {
                                 subscriber.onError(error);
                             } else {
-                                RxJavaPlugins.getInstance().getErrorHandler().handleError(error);
+                                RxJavaHooks.onError(error);
                             }
                         }
                     };
diff --git a/src/main/java/rx/internal/schedulers/ExecutorScheduler.java b/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
index a57ee8c938..b4bcf19d7f 100644
--- a/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
+++ b/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
@@ -20,7 +20,7 @@
 
 import rx.*;
 import rx.functions.Action0;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.*;
 
 /**
@@ -79,7 +79,7 @@ public Subscription schedule(Action0 action) {
                     tasks.remove(ea);
                     wip.decrementAndGet();
                     // report the error to the plugin
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(t);
+                    RxJavaHooks.onError(t);
                     // throw it to the caller
                     throw t;
                 }
@@ -158,7 +158,7 @@ public void call() {
                 ea.add(f);
             } catch (RejectedExecutionException t) {
                 // report the rejection to plugins
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(t);
+                RxJavaHooks.onError(t);
                 throw t;
             }
             
diff --git a/src/main/java/rx/internal/schedulers/NewThreadWorker.java b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
index 585d27b3b6..6521aadf46 100644
--- a/src/main/java/rx/internal/schedulers/NewThreadWorker.java
+++ b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
@@ -34,7 +34,6 @@
  */
 public class NewThreadWorker extends Scheduler.Worker implements Subscription {
     private final ScheduledExecutorService executor;
-    private final RxJavaSchedulersHook schedulersHook;
     volatile boolean isUnsubscribed;
     /** The purge frequency in milliseconds. */
     private static final String FREQUENCY_KEY = "rx.scheduler.jdk6.purge-frequency-millis";
@@ -112,7 +111,7 @@ static void purgeExecutors() {
             }
         } catch (Throwable t) {
             Exceptions.throwIfFatal(t);
-            RxJavaPlugins.getInstance().getErrorHandler().handleError(t);
+            RxJavaHooks.onError(t);
         }
     }
 
@@ -168,7 +167,7 @@ public static boolean tryEnableCancelPolicy(ScheduledExecutorService executor) {
                     methodToCall.invoke(executor, true);
                     return true;
                 } catch (Exception e) {
-                    RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                    RxJavaHooks.onError(e);
                 }
             }
         }
@@ -207,7 +206,6 @@ public NewThreadWorker(ThreadFactory threadFactory) {
         if (!cancelSupported && exec instanceof ScheduledThreadPoolExecutor) {
             registerExecutor((ScheduledThreadPoolExecutor)exec);
         }
-        schedulersHook = RxJavaPlugins.getInstance().getSchedulersHook();
         executor = exec;
     }
 
@@ -233,7 +231,7 @@ public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit
      * @return the wrapper ScheduledAction
      */
     public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit) {
-        Action0 decoratedAction = schedulersHook.onSchedule(action);
+        Action0 decoratedAction = RxJavaHooks.onScheduledAction(action);
         ScheduledAction run = new ScheduledAction(decoratedAction);
         Future<?> f;
         if (delayTime <= 0) {
@@ -246,7 +244,7 @@ public ScheduledAction scheduleActual(final Action0 action, long delayTime, Time
         return run;
     }
     public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit, CompositeSubscription parent) {
-        Action0 decoratedAction = schedulersHook.onSchedule(action);
+        Action0 decoratedAction = RxJavaHooks.onScheduledAction(action);
         ScheduledAction run = new ScheduledAction(decoratedAction, parent);
         parent.add(run);
 
@@ -262,7 +260,7 @@ public ScheduledAction scheduleActual(final Action0 action, long delayTime, Time
     }
     
     public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit, SubscriptionList parent) {
-        Action0 decoratedAction = schedulersHook.onSchedule(action);
+        Action0 decoratedAction = RxJavaHooks.onScheduledAction(action);
         ScheduledAction run = new ScheduledAction(decoratedAction, parent);
         parent.add(run);
         
diff --git a/src/main/java/rx/internal/schedulers/ScheduledAction.java b/src/main/java/rx/internal/schedulers/ScheduledAction.java
index 0f7d145a20..6ba16beaee 100644
--- a/src/main/java/rx/internal/schedulers/ScheduledAction.java
+++ b/src/main/java/rx/internal/schedulers/ScheduledAction.java
@@ -22,7 +22,7 @@
 import rx.exceptions.OnErrorNotImplementedException;
 import rx.functions.Action0;
 import rx.internal.util.SubscriptionList;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
 /**
@@ -61,7 +61,7 @@ public void run() {
             } else {
                 ie = new IllegalStateException("Fatal Exception thrown on Scheduler.Worker thread.", e);
             }
-            RxJavaPlugins.getInstance().getErrorHandler().handleError(ie);
+            RxJavaHooks.onError(ie);
             Thread thread = Thread.currentThread();
             thread.getUncaughtExceptionHandler().uncaughtException(thread, ie);
         } finally {
diff --git a/src/main/java/rx/internal/util/RxJavaPluginUtils.java b/src/main/java/rx/internal/util/RxJavaPluginUtils.java
index b6b462412c..4e459130e5 100644
--- a/src/main/java/rx/internal/util/RxJavaPluginUtils.java
+++ b/src/main/java/rx/internal/util/RxJavaPluginUtils.java
@@ -15,13 +15,13 @@
  */
 package rx.internal.util;
 
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 
 public final class RxJavaPluginUtils {
 
     public static void handleException(Throwable e) {
         try {
-            RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+            RxJavaHooks.onError(e);
         } catch (Throwable pluginException) {
             handlePluginException(pluginException);
         }
diff --git a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
index 676527f954..8c56935596 100644
--- a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
+++ b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
@@ -34,14 +34,6 @@
  * @param <T> the value type
  */
 public final class ScalarSynchronousObservable<T> extends Observable<T> {
-    /** 
-     * The execution hook instance. 
-     * <p>
-     * Can't be final to allow tests overriding it in place; if the class
-     * has been initialized, the plugin reset has no effect because
-     * how RxJavaPlugins was designed.
-     */
-    static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
     /**
      * Indicates that the Producer used by this Observable should be fully
      * threadsafe. It is possible, but unlikely that multiple concurrent
@@ -81,7 +73,7 @@ public static <T> ScalarSynchronousObservable<T> create(T t) {
     final T t;
 
     protected ScalarSynchronousObservable(final T t) {
-        super(hook.onCreate(new JustOnSubscribe<T>(t)));
+        super(RxJavaHooks.onCreate(new JustOnSubscribe<T>(t)));
         this.t = t;
     }
 
diff --git a/src/main/java/rx/observables/AsyncOnSubscribe.java b/src/main/java/rx/observables/AsyncOnSubscribe.java
index 9b8926622f..a32175fd9c 100644
--- a/src/main/java/rx/observables/AsyncOnSubscribe.java
+++ b/src/main/java/rx/observables/AsyncOnSubscribe.java
@@ -27,7 +27,7 @@
 import rx.functions.*;
 import rx.internal.operators.BufferUntilSubscriber;
 import rx.observers.SerializedObserver;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
 /**
@@ -554,7 +554,7 @@ boolean tryEmit(long n) {
 
         private void handleThrownError(Throwable ex) {
             if (hasTerminated) {
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(ex);
+                RxJavaHooks.onError(ex);
             } else {
                 hasTerminated = true;
                 merger.onError(ex);
diff --git a/src/main/java/rx/observables/SyncOnSubscribe.java b/src/main/java/rx/observables/SyncOnSubscribe.java
index 461abe28d4..34745fb118 100644
--- a/src/main/java/rx/observables/SyncOnSubscribe.java
+++ b/src/main/java/rx/observables/SyncOnSubscribe.java
@@ -18,20 +18,13 @@
 
 import java.util.concurrent.atomic.AtomicLong;
 
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Observer;
-import rx.Producer;
-import rx.Subscriber;
-import rx.Subscription;
 import rx.annotations.Beta;
 import rx.exceptions.Exceptions;
-import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.functions.Action2;
-import rx.functions.Func0;
-import rx.functions.Func2;
+import rx.functions.*;
 import rx.internal.operators.BackpressureUtils;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.RxJavaHooks;
 
 /**
  * A utility class to create {@code OnSubscribe<T>} functions that respond correctly to back
@@ -387,7 +380,7 @@ private void doUnsubscribe() {
                 parent.onUnsubscribe(state);
             } catch (Throwable e) {
                 Exceptions.throwIfFatal(e);
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                RxJavaHooks.onError(e);
             }
         }
 
@@ -422,7 +415,7 @@ private void fastpath() {
 
         private void handleThrownError(Subscriber<? super T> a, Throwable ex) {
             if (hasTerminated) {
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(ex);
+                RxJavaHooks.onError(ex);
             } else {
                 hasTerminated = true;
                 a.onError(ex);
diff --git a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
index 87160f8326..287289242d 100644
--- a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
@@ -50,6 +50,7 @@ public abstract class RxJavaCompletableExecutionHook {
      * @return {@link rx.Completable.CompletableOnSubscribe} function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
+    @Deprecated
     public Completable.CompletableOnSubscribe onCreate(Completable.CompletableOnSubscribe f) {
         return f;
     }
@@ -66,6 +67,7 @@ public Completable.CompletableOnSubscribe onCreate(Completable.CompletableOnSubs
      * @return {@link rx.Completable.CompletableOnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
+    @Deprecated
     public Completable.CompletableOnSubscribe onSubscribeStart(Completable completableInstance, final Completable.CompletableOnSubscribe onSubscribe) {
         // pass through by default
         return onSubscribe;
@@ -81,6 +83,7 @@ public Completable.CompletableOnSubscribe onSubscribeStart(Completable completab
      *            Throwable thrown by {@link Completable#subscribe(Subscriber)}
      * @return Throwable that can be decorated, replaced or just returned as a pass through
      */
+    @Deprecated
     public Throwable onSubscribeError(Throwable e) {
         // pass through by default
         return e;
@@ -98,6 +101,7 @@ public Throwable onSubscribeError(Throwable e) {
      * @return {@link rx.Completable.CompletableOperator}{@code <R, T>} function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
+    @Deprecated
     public Completable.CompletableOperator onLift(final Completable.CompletableOperator lift) {
         return lift;
     }
diff --git a/src/main/java/rx/plugins/RxJavaErrorHandler.java b/src/main/java/rx/plugins/RxJavaErrorHandler.java
index a6e56475ed..8107fab457 100644
--- a/src/main/java/rx/plugins/RxJavaErrorHandler.java
+++ b/src/main/java/rx/plugins/RxJavaErrorHandler.java
@@ -43,6 +43,7 @@ public abstract class RxJavaErrorHandler {
      * @param e
      *            the {@code Exception}
      */
+    @Deprecated
     public void handleError(Throwable e) {
         // do nothing by default
     }
@@ -57,7 +58,7 @@ public void handleError(Throwable e) {
      * Note that primitive types are always rendered as their {@code toString()} value.
      * <p>
      * If a {@code Throwable} is caught when rendering, this will fallback to the item's classname suffixed by
-     * {@value #ERROR_IN_RENDERING_SUFFIX}.
+     * {@code ERROR_IN_RENDERING_SUFFIX}.
      *
      * @param item the last emitted item, that caused the exception wrapped in
      *             {@code OnErrorThrowable.OnNextValue}
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
new file mode 100644
index 0000000000..a5b621ea19
--- /dev/null
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -0,0 +1,944 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.plugins;
+
+import java.lang.Thread.UncaughtExceptionHandler;
+
+import rx.*;
+import rx.Completable.CompletableOnSubscribe;
+import rx.Observable.*;
+import rx.annotations.Experimental;
+import rx.functions.*;
+import rx.internal.operators.*;
+
+/**
+ * Utility class that holds hooks for various Observable, Single and Completable lifecycle-related
+ * points as well as Scheduler hooks.
+ * <p>
+ * The class features a lockdown state, see {@link #lockdown()} and {@link #isLockdown()}, to
+ * prevent further changes to the hooks. 
+ */
+@Experimental
+public final class RxJavaHooks {
+    /** Utility class. */
+    private RxJavaHooks() {
+        throw new IllegalStateException("No instances!");
+    }
+    
+    /**
+     * Prevents changing the hook callbacks when set to true.
+     */
+    /* test */ static volatile boolean lockdown;
+    
+    static volatile Action1<Throwable> onError;
+    
+    @SuppressWarnings("rawtypes")
+    static volatile Func1<Observable.OnSubscribe, Observable.OnSubscribe> onObservableCreate;
+
+    @SuppressWarnings("rawtypes")
+    static volatile Func1<Single.OnSubscribe, Single.OnSubscribe> onSingleCreate;
+
+    static volatile Func1<Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> onCompletableCreate;
+
+    @SuppressWarnings("rawtypes")
+    static volatile Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> onObservableStart;
+
+    @SuppressWarnings("rawtypes")
+    static volatile Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> onSingleStart;
+
+    static volatile Func2<Completable, Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> onCompletableStart;
+
+    static volatile Func1<Scheduler, Scheduler> onComputationScheduler;
+
+    static volatile Func1<Scheduler, Scheduler> onIOScheduler;
+
+    static volatile Func1<Scheduler, Scheduler> onNewThreadScheduler;
+    
+    static volatile Func1<Action0, Action0> onScheduleAction;
+
+    static volatile Func1<Subscription, Subscription> onObservableReturn;
+
+    static volatile Func1<Subscription, Subscription> onSingleReturn;
+
+    /** Initialize with the default delegation to the original RxJavaPlugins. */
+    static {
+        init();
+    }
+    
+    /**
+     * Initialize the hooks via delegating to RxJavaPlugins.
+     */
+    @SuppressWarnings({ "rawtypes", "unchecked", "deprecation"})
+    static void init() {
+        onError = new Action1<Throwable>() {
+            @Override
+            public void call(Throwable e) {
+                RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+            }
+        };
+        
+        RxJavaPlugins.getInstance().getObservableExecutionHook();
+        
+        onObservableCreate = new Func1<OnSubscribe, OnSubscribe>() {
+            @Override
+            public OnSubscribe call(OnSubscribe f) {
+                return RxJavaPlugins.getInstance().getObservableExecutionHook().onCreate(f);
+            }
+        };
+        
+        onObservableStart = new Func2<Observable, OnSubscribe, OnSubscribe>() {
+            @Override
+            public OnSubscribe call(Observable t1, OnSubscribe t2) {
+                return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeStart(t1, t2);
+            }
+        };
+        
+        onObservableReturn = new Func1<Subscription, Subscription>() {
+            @Override
+            public Subscription call(Subscription f) {
+                return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeReturn(f);
+            }
+        };
+        
+        RxJavaPlugins.getInstance().getSingleExecutionHook();
+
+        onSingleCreate = new Func1<rx.Single.OnSubscribe, rx.Single.OnSubscribe>() {
+            @Override
+            public rx.Single.OnSubscribe call(rx.Single.OnSubscribe f) {
+                return RxJavaPlugins.getInstance().getSingleExecutionHook().onCreate(f);
+            }
+        };
+        
+        onSingleStart = new Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe>() {
+            @Override
+            public Observable.OnSubscribe call(Single t1, Observable.OnSubscribe t2) {
+                return RxJavaPlugins.getInstance().getSingleExecutionHook().onSubscribeStart(t1, t2);
+            }
+        };
+        
+        onSingleReturn = new Func1<Subscription, Subscription>() {
+            @Override
+            public Subscription call(Subscription f) {
+                return RxJavaPlugins.getInstance().getSingleExecutionHook().onSubscribeReturn(f);
+            }
+        };
+        
+        RxJavaPlugins.getInstance().getCompletableExecutionHook();
+
+        onCompletableCreate = new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
+            @Override
+            public CompletableOnSubscribe call(CompletableOnSubscribe f) {
+                return RxJavaPlugins.getInstance().getCompletableExecutionHook().onCreate(f);
+            }
+        };
+        
+        onCompletableStart = new Func2<Completable, Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe>() {
+            @Override
+            public Completable.CompletableOnSubscribe call(Completable t1, Completable.CompletableOnSubscribe t2) {
+                return RxJavaPlugins.getInstance().getCompletableExecutionHook().onSubscribeStart(t1, t2);
+            }
+        };
+
+        onScheduleAction = new Func1<Action0, Action0>() {
+            @Override
+            public Action0 call(Action0 a) {
+                return RxJavaPlugins.getInstance().getSchedulersHook().onSchedule(a);
+            }
+        };
+    }
+    
+    /**
+     * Reset all hook callbacks to those of the current RxJavaPlugins handlers.
+     * 
+     * @see #clear()
+     */
+    public static void reset() {
+        if (lockdown) {
+            return;
+        }
+        init();
+    }
+
+    /**
+     * Clears all hooks to be no-operations (and passthroughs)
+     * and onError hook to signal errors to the caller thread's
+     * UncaughtExceptionHandler.
+     * 
+     * @see #reset()
+     */
+    public static void clear() {
+        if (lockdown) {
+            return;
+        }
+        onError = null;
+        
+        onObservableCreate = null;
+        onObservableStart = null;
+        onObservableReturn = null;
+        
+        onSingleCreate = null;
+        onSingleStart = null;
+        onSingleReturn = null;
+        
+        onCompletableCreate = null;
+        onCompletableStart = null;
+        
+        onComputationScheduler = null;
+        onIOScheduler = null;
+        onNewThreadScheduler = null;
+    }
+
+    /**
+     * Prevents changing a hooks.
+     */
+    public static void lockdown() {
+        lockdown = true;
+    }
+    
+    /**
+     * Returns true if the hooks can no longer be changed.
+     * @return true if the hooks can no longer be changed
+     */
+    public static boolean isLockdown() {
+        return lockdown;
+    }
+    /**
+     * Consume undeliverable Throwables (acts as a global catch).
+     * @param ex the exception to handle
+     */
+    public static void onError(Throwable ex) {
+        Action1<Throwable> f = onError;
+        if (f != null) {
+            f.call(ex);
+            return;
+        }
+        Thread current = Thread.currentThread();
+        current.getUncaughtExceptionHandler().uncaughtException(current, ex);
+    }
+    
+    /**
+     * Hook to call when an Observable is created.
+     * @param <T> the value type
+     * @param onSubscribe the original OnSubscribe logic
+     * @return the original or replacement OnSubscribe instance
+     */
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public static <T> Observable.OnSubscribe<T> onCreate(Observable.OnSubscribe<T> onSubscribe) {
+        Func1<OnSubscribe, OnSubscribe> f = onObservableCreate;
+        if (f != null) {
+            return f.call(onSubscribe);
+        }
+        return onSubscribe;
+    }
+
+    /**
+     * Hook to call when a Single is created.
+     * @param <T> the value type
+     * @param onSubscribe the original OnSubscribe logic
+     * @return the original or replacement OnSubscribe instance
+     */
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public static <T> Single.OnSubscribe<T> onCreate(Single.OnSubscribe<T> onSubscribe) {
+        Func1<Single.OnSubscribe, Single.OnSubscribe> f = onSingleCreate;
+        if (f != null) {
+            return f.call(onSubscribe);
+        }
+        return onSubscribe;
+    }
+
+    /**
+     * Hook to call when a Completable is created.
+     * @param onSubscribe the original OnSubscribe logic
+     * @return the original or replacement OnSubscribe instance
+     */
+    public static Completable.CompletableOnSubscribe onCreate(Completable.CompletableOnSubscribe onSubscribe) {
+        Func1<Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> f = onCompletableCreate;
+        if (f != null) {
+            return f.call(onSubscribe);
+        }
+        return onSubscribe;
+    }
+    
+    /**
+     * Hook to call when the Schedulers.computation() is called.
+     * @param scheduler the default computation scheduler
+     * @return the default of alternative scheduler 
+     */
+    public static Scheduler onComputationScheduler(Scheduler scheduler) {
+        Func1<Scheduler, Scheduler> f = onComputationScheduler;
+        if (f != null) {
+            return f.call(scheduler);
+        }
+        return scheduler;
+    }
+
+    /**
+     * Hook to call when the Schedulers.io() is called.
+     * @param scheduler the default io scheduler
+     * @return the default of alternative scheduler 
+     */
+    public static Scheduler onIOScheduler(Scheduler scheduler) {
+        Func1<Scheduler, Scheduler> f = onIOScheduler;
+        if (f != null) {
+            return f.call(scheduler);
+        }
+        return scheduler;
+    }
+
+    /**
+     * Hook to call when the Schedulers.newThread() is called.
+     * @param scheduler the default new thread scheduler
+     * @return the default of alternative scheduler 
+     */
+    public static Scheduler onNewThreadScheduler(Scheduler scheduler) {
+        Func1<Scheduler, Scheduler> f = onNewThreadScheduler;
+        if (f != null) {
+            return f.call(scheduler);
+        }
+        return scheduler;
+    }
+
+    /**
+     * Hook to call before the action is scheduled, allows
+     * decorating the original action.
+     * @param action the original action
+     * @return the original or alternative action
+     */
+    public static Action0 onScheduledAction(Action0 action) {
+        Func1<Action0, Action0> f = onScheduleAction;
+        if (f != null) {
+            return f.call(action);
+        }
+        return action;
+    }
+
+    /**
+     * Hook to call before the child subscriber is subscribed to the OnSubscribe action.
+     * @param <T> the value type
+     * @param instance the parent Observable instance
+     * @param onSubscribe the original OnSubscribe action
+     * @return the original or alternative action that will be subscribed to
+     */
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public static <T> OnSubscribe<T> onObservableStart(Observable<T> instance, OnSubscribe<T> onSubscribe) {
+        Func2<Observable, OnSubscribe, OnSubscribe> f = onObservableStart;
+        if (f != null) {
+            return f.call(instance, onSubscribe);
+        }
+        return onSubscribe;
+    }
+    
+    /**
+     * Hook to call before the Observable.subscribe() method is about to return a Subscription.
+     * @param subscription the original subscription
+     * @return the original or alternative subscription that will be returned
+     */
+    public static Subscription onObservableReturn(Subscription subscription) {
+        Func1<Subscription, Subscription> f = onObservableReturn;
+        if (f != null) {
+            return f.call(subscription);
+        }
+        return subscription;
+    }
+
+    /**
+     * Hook to call if the Observable.subscribe() crashes for some reason.
+     * @param error the error
+     * @return the original error or alternative Throwable to be thrown
+     */
+    public static Throwable onObservableError(Throwable error) {
+        // TODO add hook
+        return error;
+    }
+
+    /**
+     * Hook to call before the child subscriber would subscribe to an Operator.
+     * @param <T> the input value type
+     * @param <R> the output value type
+     * @param operator the original operator
+     * @return the original or alternative operator that will be subscribed to
+     */
+    public static <T, R> Operator<R, T> onObservableLift(Operator<R, T> operator) {
+        // TODO add hook
+        return operator;
+    }
+
+    /**
+     * Hook to call before the child subscriber is subscribed to the OnSubscribe action.
+     * @param <T> the value type
+     * @param instance the parent Single instance
+     * @param onSubscribe the original OnSubscribe action
+     * @return the original or alternative action that will be subscribed to
+     */
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public static <T> Observable.OnSubscribe<T> onSingleStart(Single<T> instance, Observable.OnSubscribe<T> onSubscribe) {
+        Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> f = onSingleStart;
+        if (f != null) {
+            return f.call(instance, onSubscribe);
+        }
+        return onSubscribe;
+    }
+
+    /**
+     * Hook to call before the Single.subscribe() method is about to return a Subscription.
+     * @param subscription the original subscription
+     * @return the original or alternative subscription that will be returned
+     */
+    public static Subscription onSingleReturn(Subscription subscription) {
+        Func1<Subscription, Subscription> f = onSingleReturn;
+        if (f != null) {
+            return f.call(subscription);
+        }
+        return subscription;
+    }
+
+    /**
+     * Hook to call if the Single.subscribe() crashes for some reason.
+     * @param error the error
+     * @return the original error or alternative Throwable to be thrown
+     */
+    public static Throwable onSingleError(Throwable error) {
+        // TODO add hook
+        return error;
+    }
+
+    /**
+     * Hook to call before the child subscriber would subscribe to an Operator.
+     * @param <T> the input value type
+     * @param <R> the output value type
+     * @param operator the original operator
+     * @return the original or alternative operator that will be subscribed to
+     */
+    public static <T, R> Operator<R, T> onSingleLift(Operator<R, T> operator) {
+        // TODO add hook
+        return operator;
+    }
+
+    /**
+     * Hook to call before the child subscriber is subscribed to the OnSubscribe action.
+     * @param <T> the value type
+     * @param instance the parent Completable instance
+     * @param onSubscribe the original OnSubscribe action
+     * @return the original or alternative action that will be subscribed to
+     */
+    public static <T> Completable.CompletableOnSubscribe onCompletableStart(Completable instance, Completable.CompletableOnSubscribe onSubscribe) {
+        Func2<Completable, CompletableOnSubscribe, CompletableOnSubscribe> f = onCompletableStart;
+        if (f != null) {
+            return f.call(instance, onSubscribe);
+        }
+        return onSubscribe;
+    }
+
+    /**
+     * Hook to call if the Completable.subscribe() crashes for some reason.
+     * @param error the error
+     * @return the original error or alternative Throwable to be thrown
+     */
+    public static Throwable onCompletableError(Throwable error) {
+        // TODO add hook
+        return error;
+    }
+
+    /**
+     * Hook to call before the child subscriber would subscribe to an Operator.
+     * @param <T> the input value type
+     * @param <R> the output value type
+     * @param operator the original operator
+     * @return the original or alternative operator that will be subscribed to
+     */
+    public static <T, R> Completable.CompletableOperator onCompletableLift(Completable.CompletableOperator operator) {
+        // TODO add hook
+        return operator;
+    }
+
+    
+    /**
+     * Sets the global error consumer action unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * errors are routed to the current thread's {@link UncaughtExceptionHandler}.
+     * @param onError the action that will receive undeliverable Throwables
+     */
+    public static void setOnError(Action1<Throwable> onError) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onError = onError;
+    }
+    
+    /**
+     * Sets the Completable's onCreate hook function unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onCompletableCreate the function that takes the original CompletableOnSubscribe
+     * and should return a CompletableOnSubscribe.
+     */
+    public static void setOnCompletableCreate(
+            Func1<Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> onCompletableCreate) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onCompletableCreate = onCompletableCreate;
+    }
+    
+    /**
+     * Sets the Observable onCreate hook function unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onObservableCreate the function that takes the original OnSubscribe
+     * and should return a OnSubscribe.
+     */
+    @SuppressWarnings("rawtypes")
+    public static void setOnObservableCreate(
+            Func1<Observable.OnSubscribe, Observable.OnSubscribe> onObservableCreate) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onObservableCreate = onObservableCreate;
+    }
+    
+    /**
+     * Sets the Single onCreate hook function unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onSingleCreate the function that takes the original OnSubscribe
+     * and should return a OnSubscribe.
+     */
+    @SuppressWarnings("rawtypes")
+    public static void setOnSingleCreate(Func1<Single.OnSubscribe, Single.OnSubscribe> onSingleCreate) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onSingleCreate = onSingleCreate;
+    }
+    
+    /**
+     * Sets the hook function for returning a scheduler when the Schedulers.computation() is called
+     * unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onComputationScheduler the function that receives the original computation scheduler
+     * and should return a scheduler.
+     */
+    public static void setOnComputationScheduler(Func1<Scheduler, Scheduler> onComputationScheduler) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onComputationScheduler = onComputationScheduler;
+    }
+    
+    /**
+     * Sets the hook function for returning a scheduler when the Schedulers.io() is called
+     * unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onIOScheduler the function that receives the original io scheduler
+     * and should return a scheduler.
+     */
+    public static void setOnIOScheduler(Func1<Scheduler, Scheduler> onIOScheduler) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onIOScheduler = onIOScheduler;
+    }
+    
+    /**
+     * Sets the hook function for returning a scheduler when the Schedulers.newThread() is called
+     * unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onNewThreadScheduler the function that receives the original new thread scheduler
+     * and should return a scheduler.
+     */
+    public static void setOnNewThreadScheduler(Func1<Scheduler, Scheduler> onNewThreadScheduler) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onNewThreadScheduler = onNewThreadScheduler;
+    }
+    
+    /**
+     * Sets the hook function that is called before an action is scheduled, allowing
+     * decorating that function, unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onScheduleAction the function that receives the original action and should
+     * return an Action0.
+     */
+    public static void setOnScheduleAction(Func1<Action0, Action0> onScheduleAction) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onScheduleAction = onScheduleAction;
+    }
+    
+    /**
+     * Sets the hook function that is called when a subscriber subscribes to a Completable
+     * unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same CompletableOnSubscribe object.
+     * @param onCompletableStart the function that is called with the current Completable instance,
+     * its CompletableOnSubscribe function and should return a CompletableOnSubscribe function
+     * that gets actually subscribed to.
+     */
+    public static void setOnCompletableStart(
+            Func2<Completable, Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> onCompletableStart) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onCompletableStart = onCompletableStart;
+    }
+    
+    /**
+     * Sets the hook function that is called when a subscriber subscribes to a Observable
+     * unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same OnSubscribe object.
+     * @param onObservableStart the function that is called with the current Observable instance,
+     * its OnSubscribe function and should return a OnSubscribe function
+     * that gets actually subscribed to.
+     */
+    @SuppressWarnings("rawtypes")
+    public static void setOnObservableStart(
+            Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> onObservableStart) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onObservableStart = onObservableStart;
+    }
+    
+    /**
+     * Sets the hook function that is called when a subscriber subscribes to a Single
+     * unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same OnSubscribe object.
+     * @param onSingleStart the function that is called with the current Single instance,
+     * its OnSubscribe function and should return a OnSubscribe function
+     * that gets actually subscribed to.
+     */
+    @SuppressWarnings("rawtypes")
+    public static void setOnSingleStart(Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> onSingleStart) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onSingleStart = onSingleStart;
+    }
+    
+    /**
+     * Sets a hook function that is called when the Observable.subscribe() call 
+     * is about to return a Subscription unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onObservableReturn the function that is called with the Subscriber that has been
+     * subscribed to the OnSubscribe function and returns a Subscription that will be returned by
+     * subscribe().
+     */
+    public static void setOnObservableReturn(Func1<Subscription, Subscription> onObservableReturn) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onObservableReturn = onObservableReturn;
+    }
+    
+    /**
+     * Sets a hook function that is called when the Single.subscribe() call 
+     * is about to return a Subscription unless a lockdown is in effect.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onSingleReturn the function that is called with the SingleSubscriber that has been
+     * subscribed to the OnSubscribe function and returns a Subscription that will be returned by
+     * subscribe().
+     */
+    public static void setOnSingleReturn(Func1<Subscription, Subscription> onSingleReturn) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onSingleReturn = onSingleReturn;
+    }
+    
+    /**
+     * Returns the current computation scheduler hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func1<Scheduler, Scheduler> getOnComputationScheduler() {
+        return onComputationScheduler;
+    }
+    
+    /**
+     * Returns the current global error handler hook action or null if it is
+     * set to the default one that signals errors to the current threads
+     * UncaughtExceptionHandler.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook action
+     */
+    public static Action1<Throwable> getOnError() {
+        return onError;
+    }
+    
+    /**
+     * Returns the current io scheduler hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func1<Scheduler, Scheduler> getOnIOScheduler() {
+        return onIOScheduler;
+    }
+    
+    /**
+     * Returns the current new thread scheduler hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func1<Scheduler, Scheduler> getOnNewThreadScheduler() {
+        return onNewThreadScheduler;
+    }
+    
+    /**
+     * Returns the current Observable onCreate hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    @SuppressWarnings("rawtypes")
+    public static Func1<Observable.OnSubscribe, Observable.OnSubscribe> getOnObservableCreate() {
+        return onObservableCreate;
+    }
+    
+    /**
+     * Returns the current schedule action hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func1<Action0, Action0> getOnScheduleAction() {
+        return onScheduleAction;
+    }
+    
+    /**
+     * Returns the current Single onCreate hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    @SuppressWarnings("rawtypes")
+    public static Func1<Single.OnSubscribe, Single.OnSubscribe> getOnSingleCreate() {
+        return onSingleCreate;
+    }
+    
+    /**
+     * Returns the current Completable onCreate hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func1<Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> getOnCompletableCreate() {
+        return onCompletableCreate;
+    }
+    
+    /**
+     * Returns the current Completable onStart hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func2<Completable, Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> getOnCompletableStart() {
+        return onCompletableStart;
+    }
+    
+    /**
+     * Returns the current Observable onStart hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    @SuppressWarnings("rawtypes")
+    public static Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> getOnObservableStart() {
+        return onObservableStart;
+    }
+    
+    /**
+     * Returns the current Single onStart hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    @SuppressWarnings("rawtypes")
+    public static Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> getOnSingleStart() {
+        return onSingleStart;
+    }
+    
+    /**
+     * Returns the current Observable onReturn hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func1<Subscription, Subscription> getOnObservableReturn() {
+        return onObservableReturn;
+    }
+    
+    /**
+     * Returns the current Single onReturn hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func1<Subscription, Subscription> getOnSingleReturn() {
+        return onSingleReturn;
+    }
+
+    /**
+     * Resets the assembly tracking hooks to their default delegates to
+     * RxJavaPlugins.
+     */
+    @SuppressWarnings({ "rawtypes", "unchecked", "deprecation" })
+    public static void resetAssemblyTracking() {
+        if (lockdown) {
+            return;
+        }
+
+        RxJavaPlugins plugin = RxJavaPlugins.getInstance();
+        
+        final RxJavaObservableExecutionHook observableExecutionHook = plugin.getObservableExecutionHook();
+        
+        onObservableCreate = new Func1<OnSubscribe, OnSubscribe>() {
+            @Override
+            public OnSubscribe call(OnSubscribe f) {
+                return observableExecutionHook.onCreate(f);
+            }
+        };
+        
+        final RxJavaSingleExecutionHook singleExecutionHook = plugin.getSingleExecutionHook();
+
+        onSingleCreate = new Func1<rx.Single.OnSubscribe, rx.Single.OnSubscribe>() {
+            @Override
+            public rx.Single.OnSubscribe call(rx.Single.OnSubscribe f) {
+                return singleExecutionHook.onCreate(f);
+            }
+        };
+        
+        final RxJavaCompletableExecutionHook completableExecutionHook = plugin.getCompletableExecutionHook();
+
+        onCompletableCreate = new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
+            @Override
+            public CompletableOnSubscribe call(CompletableOnSubscribe f) {
+                return completableExecutionHook.onCreate(f);
+            }
+        };
+
+    }
+
+    /**
+     * Clears the assembly tracking hooks to their default pass-through behavior.
+     */
+    public static void crearAssemblyTracking() {
+        if (lockdown) {
+            return;
+        }
+        onObservableCreate = null;
+        onSingleCreate = null;
+        onCompletableCreate = null;
+    }
+
+    /**
+     * Sets up hooks that capture the current stacktrace when a source or an
+     * operator is instantiated, keeping it in a field for debugging purposes
+     * and alters exceptions passign along to hold onto this stacktrace.
+     */
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public static void enableAssemblyTracking() {
+        if (lockdown) {
+            return;
+        }
+        
+        onObservableCreate = new Func1<OnSubscribe, OnSubscribe>() {
+            @Override
+            public OnSubscribe call(OnSubscribe f) {
+                return new OnSubscribeOnAssembly(f);
+            }
+        };
+
+        onSingleCreate = new Func1<rx.Single.OnSubscribe, rx.Single.OnSubscribe>() {
+            @Override
+            public rx.Single.OnSubscribe call(rx.Single.OnSubscribe f) {
+                return new OnSubscribeOnAssemblySingle(f);
+            }
+        };
+
+        onCompletableCreate = new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
+            @Override
+            public CompletableOnSubscribe call(CompletableOnSubscribe f) {
+                return new OnSubscribeOnAssemblyCompletable(f);
+            }
+        };
+
+    }
+}
diff --git a/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index c7c085c7fe..8c08851ed5 100644
--- a/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -52,6 +52,7 @@ public abstract class RxJavaObservableExecutionHook {
      * @return {@link OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
+    @Deprecated
     public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
         return f;
     }
@@ -69,6 +70,7 @@ public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
      * @return {@link OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
+    @Deprecated
     public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableInstance, final OnSubscribe<T> onSubscribe) {
         // pass through by default
         return onSubscribe;
@@ -87,6 +89,7 @@ public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableIns
      * @return {@link Subscription} subscription that can be modified, decorated, replaced or just returned as a
      *         pass through
      */
+    @Deprecated
     public <T> Subscription onSubscribeReturn(Subscription subscription) {
         // pass through by default
         return subscription;
@@ -103,6 +106,7 @@ public <T> Subscription onSubscribeReturn(Subscription subscription) {
      *            Throwable thrown by {@link Observable#subscribe(Subscriber)}
      * @return Throwable that can be decorated, replaced or just returned as a pass through
      */
+    @Deprecated
     public <T> Throwable onSubscribeError(Throwable e) {
         // pass through by default
         return e;
@@ -122,6 +126,7 @@ public <T> Throwable onSubscribeError(Throwable e) {
      * @return {@link Operator}{@code <R, T>} function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
+    @Deprecated
     public <T, R> Operator<? extends R, ? super T> onLift(final Operator<? extends R, ? super T> lift) {
         return lift;
     }
diff --git a/src/main/java/rx/plugins/RxJavaPlugins.java b/src/main/java/rx/plugins/RxJavaPlugins.java
index f9926ac588..9271a42ce2 100644
--- a/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -45,6 +45,9 @@
  * </code></pre>
  * 
  * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Plugins">RxJava Wiki: Plugins</a>
+ * 
+ * Use the {@link RxJavaHooks} features instead which let's you change individual
+ * handlers at runtime.
  */
 public class RxJavaPlugins {
     private final static RxJavaPlugins INSTANCE = new RxJavaPlugins();
@@ -59,7 +62,10 @@ public class RxJavaPlugins {
      * Retrieves the single {@code RxJavaPlugins} instance.
      *
      * @return the single {@code RxJavaPlugins} instance
+     * 
+     * @deprecated use the static methods of {@link RxJavaHooks}.
      */
+    @Deprecated
     public static RxJavaPlugins getInstance() {
         return INSTANCE;
     }
diff --git a/src/main/java/rx/plugins/RxJavaSchedulersHook.java b/src/main/java/rx/plugins/RxJavaSchedulersHook.java
index e50d6a611e..a8158e2f5e 100644
--- a/src/main/java/rx/plugins/RxJavaSchedulersHook.java
+++ b/src/main/java/rx/plugins/RxJavaSchedulersHook.java
@@ -148,6 +148,7 @@ public Scheduler getNewThreadScheduler() {
      * @param action action to schedule
      * @return wrapped action to schedule
      */
+    @Deprecated
     public Action0 onSchedule(Action0 action) {
         return action;
     }
diff --git a/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java b/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
index ed780381b8..4e023f615e 100644
--- a/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
@@ -51,6 +51,7 @@ public abstract class RxJavaSingleExecutionHook {
      * @return {@link rx.Single.OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
+    @Deprecated
     public <T> Single.OnSubscribe<T> onCreate(Single.OnSubscribe<T> f) {
         return f;
     }
@@ -68,6 +69,7 @@ public <T> Single.OnSubscribe<T> onCreate(Single.OnSubscribe<T> f) {
      * @return {@link rx.Observable.OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
+    @Deprecated
     public <T> Observable.OnSubscribe<T> onSubscribeStart(Single<? extends T> singleInstance, final Observable.OnSubscribe<T> onSubscribe) {
         // pass through by default
         return onSubscribe;
@@ -86,6 +88,7 @@ public <T> Observable.OnSubscribe<T> onSubscribeStart(Single<? extends T> single
      * @return {@link Subscription} subscription that can be modified, decorated, replaced or just returned as a
      *         pass through
      */
+    @Deprecated
     public <T> Subscription onSubscribeReturn(Subscription subscription) {
         // pass through by default
         return subscription;
@@ -102,6 +105,7 @@ public <T> Subscription onSubscribeReturn(Subscription subscription) {
      *            Throwable thrown by {@link Single#subscribe(Subscriber)}
      * @return Throwable that can be decorated, replaced or just returned as a pass through
      */
+    @Deprecated
     public <T> Throwable onSubscribeError(Throwable e) {
         // pass through by default
         return e;
@@ -121,6 +125,7 @@ public <T> Throwable onSubscribeError(Throwable e) {
      * @return {@link rx.Observable.Operator}{@code <R, T>} function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
+    @Deprecated
     public <T, R> Observable.Operator<? extends R, ? super T> onLift(final Observable.Operator<? extends R, ? super T> lift) {
         return lift;
     }
diff --git a/src/main/java/rx/schedulers/Schedulers.java b/src/main/java/rx/schedulers/Schedulers.java
index 031d0bb463..6dc89f0178 100644
--- a/src/main/java/rx/schedulers/Schedulers.java
+++ b/src/main/java/rx/schedulers/Schedulers.java
@@ -21,8 +21,7 @@
 import rx.internal.schedulers.GenericScheduledExecutorService;
 import rx.internal.schedulers.SchedulerLifecycle;
 import rx.internal.util.RxRingBuffer;
-import rx.plugins.RxJavaPlugins;
-import rx.plugins.RxJavaSchedulersHook;
+import rx.plugins.*;
 
 import java.util.concurrent.Executor;
 import java.util.concurrent.atomic.AtomicReference;
@@ -54,6 +53,7 @@ private static Schedulers getInstance() {
     }
 
     private Schedulers() {
+        @SuppressWarnings("deprecation")
         RxJavaSchedulersHook hook = RxJavaPlugins.getInstance().getSchedulersHook();
 
         Scheduler c = hook.getComputationScheduler();
@@ -105,7 +105,7 @@ public static Scheduler trampoline() {
      * @return a {@link Scheduler} that creates new threads
      */
     public static Scheduler newThread() {
-        return getInstance().newThreadScheduler;
+        return RxJavaHooks.onNewThreadScheduler(getInstance().newThreadScheduler);
     }
 
     /**
@@ -120,7 +120,7 @@ public static Scheduler newThread() {
      * @return a {@link Scheduler} meant for computation-bound work
      */
     public static Scheduler computation() {
-        return getInstance().computationScheduler;
+        return RxJavaHooks.onComputationScheduler(getInstance().computationScheduler);
     }
 
     /**
@@ -137,7 +137,7 @@ public static Scheduler computation() {
      * @return a {@link Scheduler} meant for IO-bound work
      */
     public static Scheduler io() {
-        return getInstance().ioScheduler;
+        return RxJavaHooks.onComputationScheduler(getInstance().ioScheduler);
     }
 
     /**
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 4aee2eed85..ca267be435 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -31,7 +31,7 @@
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.observers.TestSubscriber;
-import rx.plugins.*;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.*;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.*;
@@ -1216,7 +1216,7 @@ public void onCompleted() {
             
             @Override
             public void onError(Throwable e) {
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                RxJavaHooks.onError(e);
             }
         });
 
@@ -4036,13 +4036,34 @@ public void onNext(Object t) {
         }
     }
 
-    private static RxJavaCompletableExecutionHook hookSpy;
+    private Func1<CompletableOnSubscribe, CompletableOnSubscribe> onCreate;
+    
+    private Func2<Completable, CompletableOnSubscribe, CompletableOnSubscribe> onStart;
 
     @Before
     public void setUp() throws Exception {
-        hookSpy = spy(
-                new RxJavaPluginsTest.RxJavaCompletableExecutionHookTestImpl());
-        Completable.HOOK = hookSpy;
+        onCreate = spy(new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
+            @Override
+            public CompletableOnSubscribe call(CompletableOnSubscribe t) {
+                return t;
+            }
+        });
+        
+        RxJavaHooks.setOnCompletableCreate(onCreate);
+        
+        onStart = spy(new Func2<Completable, CompletableOnSubscribe, CompletableOnSubscribe>() {
+            @Override
+            public CompletableOnSubscribe call(Completable t1, CompletableOnSubscribe t2) {
+                return t2;
+            }
+        });
+        
+        RxJavaHooks.setOnCompletableStart(onStart);
+    }
+    
+    @After
+    public void after() {
+        RxJavaHooks.reset();
     }
 
     @Test
@@ -4050,7 +4071,7 @@ public void testHookCreate() {
         CompletableOnSubscribe subscriber = mock(CompletableOnSubscribe.class);
         Completable.create(subscriber);
 
-        verify(hookSpy, times(1)).onCreate(subscriber);
+        verify(onCreate, times(1)).call(subscriber);
     }
 
     @Test
@@ -4064,7 +4085,7 @@ public void testHookSubscribeStart() {
         });
         completable.subscribe(ts);
 
-        verify(hookSpy, times(1)).onSubscribeStart(eq(completable), any(Completable.CompletableOnSubscribe.class));
+        verify(onStart, times(1)).call(eq(completable), any(Completable.CompletableOnSubscribe.class));
     }
 
     @Test
@@ -4077,7 +4098,7 @@ public void testHookUnsafeSubscribeStart() {
         });
         completable.unsafeSubscribe(ts);
 
-        verify(hookSpy, times(1)).onSubscribeStart(eq(completable), any(Completable.CompletableOnSubscribe.class));
+        verify(onStart, times(1)).call(eq(completable), any(Completable.CompletableOnSubscribe.class));
     }
 
     @Test
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index 12b059e648..7f45192044 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -21,33 +21,64 @@
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.*;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
 import rx.Single.OnSubscribe;
 import rx.exceptions.*;
 import rx.functions.*;
-import rx.observers.SafeSubscriber;
-import rx.observers.TestSubscriber;
-import rx.plugins.RxJavaPluginsTest;
-import rx.plugins.RxJavaSingleExecutionHook;
-import rx.schedulers.Schedulers;
-import rx.schedulers.TestScheduler;
+import rx.observers.*;
+import rx.plugins.RxJavaHooks;
+import rx.schedulers.*;
 import rx.singles.BlockingSingle;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 
 public class SingleTest {
 
-    private static RxJavaSingleExecutionHook hookSpy;
+    @SuppressWarnings("rawtypes")
+    private Func1<Single.OnSubscribe, Single.OnSubscribe> onCreate;
+    
+    @SuppressWarnings("rawtypes")
+    private Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> onStart;
 
+    private Func1<Subscription, Subscription> onReturn;
+
+    @SuppressWarnings("rawtypes")
     @Before
     public void setUp() throws Exception {
-        hookSpy = spy(
-                new RxJavaPluginsTest.RxJavaSingleExecutionHookTestImpl());
-        Single.hook = hookSpy;
+        onCreate = spy(new Func1<Single.OnSubscribe, Single.OnSubscribe>() {
+            @Override
+            public Single.OnSubscribe call(Single.OnSubscribe t) {
+                return t;
+            }
+        });
+        
+        RxJavaHooks.setOnSingleCreate(onCreate);
+        
+        onStart = spy(new Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe>() {
+            @Override
+            public Observable.OnSubscribe call(Single t1, Observable.OnSubscribe t2) {
+                return t2;
+            }
+        });
+        
+        RxJavaHooks.setOnSingleStart(onStart);
+        
+        onReturn = spy(new Func1<Subscription, Subscription>() {
+            @Override
+            public Subscription call(Subscription t) {
+                return t;
+            }
+        });
+        
+        RxJavaHooks.setOnSingleReturn(onReturn);
+    }
+    
+    @After
+    public void after() {
+        RxJavaHooks.reset();
     }
 
     @Test
@@ -400,10 +431,9 @@ public void testHookCreate() {
         OnSubscribe<Object> subscriber = mock(OnSubscribe.class);
         Single.create(subscriber);
 
-        verify(hookSpy, times(1)).onCreate(subscriber);
+        verify(onCreate, times(1)).call(subscriber);
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void testHookSubscribeStart() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
@@ -415,10 +445,9 @@ public void testHookSubscribeStart() {
         });
         single.subscribe(ts);
 
-        verify(hookSpy, times(1)).onSubscribeStart(eq(single), any(Observable.OnSubscribe.class));
+        verify(onStart, times(1)).call(eq(single), any(Observable.OnSubscribe.class));
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void testHookUnsafeSubscribeStart() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
@@ -429,7 +458,7 @@ public void testHookUnsafeSubscribeStart() {
         });
         single.unsafeSubscribe(ts);
 
-        verify(hookSpy, times(1)).onSubscribeStart(eq(single), any(Observable.OnSubscribe.class));
+        verify(onStart, times(1)).call(eq(single), any(Observable.OnSubscribe.class));
     }
 
     @Test
@@ -443,7 +472,7 @@ public void testHookSubscribeReturn() {
         });
         single.subscribe(ts);
 
-        verify(hookSpy, times(1)).onSubscribeReturn(any(SafeSubscriber.class));
+        verify(onReturn, times(1)).call(any(SafeSubscriber.class));
     }
 
     @Test
@@ -457,7 +486,7 @@ public void testHookUnsafeSubscribeReturn() {
         });
         single.unsafeSubscribe(ts);
 
-        verify(hookSpy, times(1)).onSubscribeReturn(ts);
+        verify(onReturn, times(1)).call(ts);
     }
 
     @Test
diff --git a/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java b/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java
index 6898fbd472..6c2386812b 100644
--- a/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java
+++ b/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java
@@ -235,19 +235,21 @@ public void onNext(Integer t) {
         ts.assertNotCompleted();
     }
     
+    @SuppressWarnings("rawtypes")
     @Test
     public void hookCalled() {
-        RxJavaObservableExecutionHook save = ScalarSynchronousObservable.hook;
+        Func1<OnSubscribe, OnSubscribe> save = RxJavaHooks.getOnObservableCreate();
         try {
             final AtomicInteger c = new AtomicInteger();
             
-            ScalarSynchronousObservable.hook = new RxJavaObservableExecutionHook() {
+            
+            RxJavaHooks.setOnObservableCreate(new Func1<OnSubscribe, OnSubscribe>() {
                 @Override
-                public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
+                public OnSubscribe call(OnSubscribe t) {
                     c.getAndIncrement();
-                    return f;
+                    return t;
                 }
-            };
+            });
             
             int n = 10;
             
@@ -257,22 +259,23 @@ public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
             
             Assert.assertEquals(n, c.get());
         } finally {
-            ScalarSynchronousObservable.hook = save;
+            RxJavaHooks.setOnObservableCreate(save);
         }
     }
 
+    @SuppressWarnings("rawtypes")
     @Test
     public void hookChangesBehavior() {
-        RxJavaObservableExecutionHook save = ScalarSynchronousObservable.hook;
+        Func1<OnSubscribe, OnSubscribe> save = RxJavaHooks.getOnObservableCreate();
         try {
-            ScalarSynchronousObservable.hook = new RxJavaObservableExecutionHook() {
+            RxJavaHooks.setOnObservableCreate(new Func1<OnSubscribe, OnSubscribe>() {
                 @Override
-                public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
+                public OnSubscribe call(OnSubscribe f) {
                     if (f instanceof ScalarSynchronousObservable.JustOnSubscribe) {
-                        final T v = ((ScalarSynchronousObservable.JustOnSubscribe<T>) f).value;
-                        return new OnSubscribe<T>() {
+                        final Object v = ((ScalarSynchronousObservable.JustOnSubscribe) f).value;
+                        return new OnSubscribe<Object>() {
                             @Override
-                            public void call(Subscriber<? super T> t) {
+                            public void call(Subscriber<? super Object> t) {
                                 t.onNext(v);
                                 t.onNext(v);
                                 t.onCompleted();
@@ -281,7 +284,7 @@ public void call(Subscriber<? super T> t) {
                     }
                     return f;
                 }
-            };
+            });
             
             TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
             
@@ -292,7 +295,7 @@ public void call(Subscriber<? super T> t) {
             ts.assertCompleted();
             
         } finally {
-            ScalarSynchronousObservable.hook = save;
+            RxJavaHooks.setOnObservableCreate(save);
         }
     }
 
diff --git a/src/test/java/rx/observers/SafeSubscriberTest.java b/src/test/java/rx/observers/SafeSubscriberTest.java
index c11c2b37a0..30d4ee905b 100644
--- a/src/test/java/rx/observers/SafeSubscriberTest.java
+++ b/src/test/java/rx/observers/SafeSubscriberTest.java
@@ -18,7 +18,6 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import java.lang.reflect.Method;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.After;
@@ -36,20 +35,13 @@
 import rx.plugins.RxJavaPlugins;
 import rx.subscriptions.Subscriptions;
 
+@SuppressWarnings("deprecation")
 public class SafeSubscriberTest {
     
     @Before
     @After
     public void resetBefore() {
-        RxJavaPlugins ps = RxJavaPlugins.getInstance();
-        
-        try {
-            Method m = ps.getClass().getDeclaredMethod("reset");
-            m.setAccessible(true);
-            m.invoke(ps);
-        } catch (Throwable ex) {
-            ex.printStackTrace();
-        }
+        RxJavaPlugins.getInstance().reset();
     }
 
     @Test
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
new file mode 100644
index 0000000000..2072e72d49
--- /dev/null
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -0,0 +1,165 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.plugins;
+
+import java.lang.reflect.Method;
+
+import org.junit.*;
+
+import rx.*;
+import rx.exceptions.*;
+import rx.functions.*;
+import rx.internal.util.UtilityFunctions;
+import rx.observers.TestSubscriber;
+
+public class RxJavaHooksTest {
+
+    static Observable<Integer> createObservable() {
+        return Observable.range(1, 5).map(new Func1<Integer, Integer>() {
+            @Override
+            public Integer call(Integer t) {
+                throw new TestException();
+            }
+        });
+    }
+    
+    @Test
+    public void assemblyTrackingObservable() {
+        RxJavaHooks.enableAssemblyTracking();
+        try {
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            createObservable().subscribe(ts);
+            
+            ts.assertError(AssemblyStackTraceException.class);
+            
+            Throwable ex = ts.getOnErrorEvents().get(0);
+            
+            Assert.assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
+            
+            Assert.assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
+            
+            Assert.assertTrue(ex.getMessage(), ex.getMessage().contains("createObservable"));
+        } finally {
+            RxJavaHooks.resetAssemblyTracking();
+        }
+    }
+    
+    static Single<Integer> createSingle() {
+        return Single.just(1).map(new Func1<Integer, Integer>() {
+            @Override
+            public Integer call(Integer t) {
+                throw new TestException();
+            }
+        });
+    }
+    
+    @Test
+    public void assemblyTrackingSingle() {
+        RxJavaHooks.enableAssemblyTracking();
+        try {
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            createSingle().subscribe(ts);
+            
+            ts.assertError(AssemblyStackTraceException.class);
+            
+            Throwable ex = ts.getOnErrorEvents().get(0);
+
+            Assert.assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
+
+            Assert.assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
+
+            Assert.assertTrue(ex.getMessage(), ex.getMessage().contains("createSingle"));
+        } finally {
+            RxJavaHooks.resetAssemblyTracking();
+        }
+    }
+    
+    static Completable createCompletable() {
+        return Completable.error(new Func0<Throwable>() {
+            @Override
+            public Throwable call() {
+                return new TestException();
+            }
+        });
+    }
+    
+    @Test
+    public void assemblyTrackingCompletable() {
+        RxJavaHooks.enableAssemblyTracking();
+        try {
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            createCompletable().subscribe(ts);
+            
+            ts.assertError(AssemblyStackTraceException.class);
+            
+            Throwable ex = ts.getOnErrorEvents().get(0);
+
+            Assert.assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
+
+            Assert.assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
+
+            Assert.assertTrue(ex.getMessage(), ex.getMessage().contains("createCompletable"));
+        } finally {
+            RxJavaHooks.resetAssemblyTracking();
+        }
+    }
+    
+    @SuppressWarnings("rawtypes")
+    @Test
+    public void lockdown() throws Exception {
+        RxJavaHooks.reset();
+        RxJavaHooks.lockdown();
+        try {
+            Action1 a1 = Actions.empty();
+            Func1 f1 = UtilityFunctions.identity();
+            Func2 f2 = new Func2() {
+                @Override
+                public Object call(Object t1, Object t2) {
+                    return t2;
+                }
+            };
+            
+            for (Method m : RxJavaHooks.class.getMethods()) {
+                if (m.getName().startsWith("setOn")) {
+                    
+                    Method getter = RxJavaHooks.class.getMethod("get" + m.getName().substring(3));
+                    
+                    Object before = getter.invoke(null);
+                    
+                    if (m.getParameterTypes()[0].isAssignableFrom(Func1.class)) {
+                        m.invoke(null, f1);
+                    } else
+                    if (m.getParameterTypes()[0].isAssignableFrom(Action1.class)) {
+                        m.invoke(null, a1);
+                    } else {
+                        m.invoke(null, f2);
+                    }
+                    
+                    Object after = getter.invoke(null);
+                    
+                    Assert.assertSame(m.toString(), before, after);
+                }
+            }
+            
+        } finally {
+            RxJavaHooks.lockdown = false;
+            RxJavaHooks.reset();
+        }
+    }
+}
diff --git a/src/test/java/rx/plugins/RxJavaPluginsTest.java b/src/test/java/rx/plugins/RxJavaPluginsTest.java
index 9c471cfa9c..b4171ea11a 100644
--- a/src/test/java/rx/plugins/RxJavaPluginsTest.java
+++ b/src/test/java/rx/plugins/RxJavaPluginsTest.java
@@ -28,6 +28,7 @@
 import rx.exceptions.OnErrorThrowable;
 import rx.functions.Func1;
 
+@SuppressWarnings("deprecation")
 public class RxJavaPluginsTest {
 
     @Before
diff --git a/src/test/java/rx/schedulers/ResetSchedulersTest.java b/src/test/java/rx/schedulers/ResetSchedulersTest.java
index 79c9f9435b..2fc2c4eaa4 100644
--- a/src/test/java/rx/schedulers/ResetSchedulersTest.java
+++ b/src/test/java/rx/schedulers/ResetSchedulersTest.java
@@ -11,6 +11,7 @@
 
 public class ResetSchedulersTest {
 
+    @SuppressWarnings("deprecation")
     @Test
     public void reset() {
         RxJavaPlugins.getInstance().reset();

From 90e4204f751a5d0b74061e3ae33bff59b93de410 Mon Sep 17 00:00:00 2001
From: Shixiong Zhu <zsxwing@gmail.com>
Date: Thu, 23 Jun 2016 00:14:22 -0700
Subject: [PATCH 077/263] 1.x: Remove unnecessary dependency in build.gradle
 (#4086)

---
 build.gradle | 2 --
 1 file changed, 2 deletions(-)

diff --git a/build.gradle b/build.gradle
index 5b1a651f19..9f846638b2 100644
--- a/build.gradle
+++ b/build.gradle
@@ -78,8 +78,6 @@ pmdMain {
     }
 }
 
-build.dependsOn pmdMain
-
 task pmdPrint(dependsOn: 'pmdMain') << {
     File file = new File('build/reports/pmd/main.xml')
     if (file.exists()) {

From afe3cb0b90ae4bb87760bce85048717926862993 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 23 Jun 2016 09:49:20 +0200
Subject: [PATCH 078/263] 1.x: fix some flaky tests, add more timeout to others
 (#4088)

---
 src/test/java/rx/CompletableTest.java         | 360 +++++++++---------
 .../operators/BlockingOperatorNextTest.java   |  64 ++--
 .../operators/OperatorSwitchTest.java         |   2 +-
 3 files changed, 215 insertions(+), 211 deletions(-)

diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index ca267be435..0d495cec67 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -148,7 +148,7 @@ public void assertSubscriptions(int n) {
     /** An error Completable object. */
     final ErrorCompletable error = new ErrorCompletable();
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void complete() {
         Completable c = Completable.complete();
         
@@ -160,14 +160,14 @@ public void concatNull() {
         Completable.concat((Completable[])null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void concatEmpty() {
         Completable c = Completable.concat();
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void concatSingleSource() {
         Completable c = Completable.concat(normal.completable);
         
@@ -176,14 +176,14 @@ public void concatSingleSource() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void concatSingleSourceThrows() {
         Completable c = Completable.concat(error.completable);
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void concatMultipleSources() {
         Completable c = Completable.concat(normal.completable, normal.completable, normal.completable);
         
@@ -192,21 +192,21 @@ public void concatMultipleSources() {
         normal.assertSubscriptions(3);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void concatMultipleOneThrows() {
         Completable c = Completable.concat(normal.completable, error.completable, normal.completable);
         
         c.await();
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void concatMultipleOneIsNull() {
         Completable c = Completable.concat(normal.completable, null);
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void concatIterableEmpty() {
         Completable c = Completable.concat(Collections.<Completable>emptyList());
         
@@ -218,7 +218,7 @@ public void concatIterableNull() {
         Completable.concat((Iterable<Completable>)null);
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void concatIterableIteratorNull() {
         Completable c = Completable.concat(new Iterable<Completable>() {
             @Override
@@ -230,14 +230,14 @@ public Iterator<Completable> iterator() {
         c.await();
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void concatIterableWithNull() {
         Completable c = Completable.concat(Arrays.asList(normal.completable, (Completable)null));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void concatIterableSingle() {
         Completable c = Completable.concat(Collections.singleton(normal.completable));
         
@@ -246,7 +246,7 @@ public void concatIterableSingle() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void concatIterableMany() {
         Completable c = Completable.concat(Arrays.asList(normal.completable, normal.completable, normal.completable));
         
@@ -255,14 +255,14 @@ public void concatIterableMany() {
         normal.assertSubscriptions(3);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void concatIterableOneThrows() {
         Completable c = Completable.concat(Collections.singleton(error.completable));
         
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void concatIterableManyOneThrows() {
         Completable c = Completable.concat(Arrays.asList(normal.completable, error.completable));
         
@@ -295,21 +295,21 @@ public void concatIterableIteratorNextThrows() {
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void concatObservableEmpty() {
         Completable c = Completable.concat(Observable.<Completable>empty());
         
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void concatObservableError() {
         Completable c = Completable.concat(Observable.<Completable>error(new TestException()));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void concatObservableSingle() {
         Completable c = Completable.concat(Observable.just(normal.completable));
         
@@ -318,14 +318,14 @@ public void concatObservableSingle() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void concatObservableSingleThrows() {
         Completable c = Completable.concat(Observable.just(error.completable));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void concatObservableMany() {
         Completable c = Completable.concat(Observable.just(normal.completable).repeat(3));
         
@@ -334,14 +334,14 @@ public void concatObservableMany() {
         normal.assertSubscriptions(3);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void concatObservableManyOneThrows() {
         Completable c = Completable.concat(Observable.just(normal.completable, error.completable));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void concatObservablePrefetch() {
         final List<Long> requested = new ArrayList<Long>();
         Observable<Completable> cs = Observable
@@ -480,7 +480,7 @@ public void createNull() {
         Completable.create(null);
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void createOnSubscribeThrowsNPE() {
         Completable c = Completable.create(new CompletableOnSubscribe() {
             @Override
@@ -490,7 +490,7 @@ public void createOnSubscribeThrowsNPE() {
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void createOnSubscribeThrowsRuntimeException() {
         try {
             Completable c = Completable.create(new CompletableOnSubscribe() {
@@ -511,7 +511,7 @@ public void call(CompletableSubscriber s) {
         }
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void defer() {
         Completable c = Completable.defer(new Func0<Completable>() {
             @Override
@@ -532,7 +532,7 @@ public void deferNull() {
         Completable.defer(null);
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void deferReturnsNull() {
         Completable c = Completable.defer(new Func0<Completable>() {
             @Override
@@ -544,7 +544,7 @@ public Completable call() {
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void deferFunctionThrows() {
         Completable c = Completable.defer(new Func0<Completable>() {
             @Override
@@ -554,7 +554,7 @@ public void deferFunctionThrows() {
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void deferErrorSource() {
         Completable c = Completable.defer(new Func0<Completable>() {
             @Override
@@ -571,7 +571,7 @@ public void errorNull() {
         Completable.error((Throwable)null);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void errorNormal() {
         Completable c = Completable.error(new TestException());
         
@@ -583,7 +583,7 @@ public void fromCallableNull() {
         Completable.fromCallable(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void fromCallableNormal() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -599,7 +599,7 @@ public Object call() throws Exception {
         Assert.assertEquals(1, calls.get());
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void fromCallableThrows() {
         Completable c = Completable.fromCallable(new Callable<Object>() {
             @Override
@@ -614,7 +614,7 @@ public void fromObservableNull() {
         Completable.fromObservable(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void fromObservableEmpty() {
         Completable c = Completable.fromObservable(Observable.empty());
         
@@ -630,7 +630,7 @@ public void fromObservableSome() {
         }
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void fromObservableError() {
         Completable c = Completable.fromObservable(Observable.error(new TestException()));
         
@@ -642,7 +642,7 @@ public void fromFutureNull() {
         Completable.fromFuture(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void fromFutureNormal() {
         ExecutorService exec = Executors.newSingleThreadExecutor();
         
@@ -660,7 +660,7 @@ public void run() {
         }
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void fromFutureThrows() {
         ExecutorService exec = Executors.newSingleThreadExecutor();
         
@@ -689,7 +689,7 @@ public void fromActionNull() {
         Completable.fromAction(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void fromActionNormal() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -705,7 +705,7 @@ public void call() {
         Assert.assertEquals(1, calls.get());
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void fromActionThrows() {
         Completable c = Completable.fromAction(new Action0() {
             @Override
@@ -720,14 +720,14 @@ public void fromSingleNull() {
         Completable.fromSingle(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void fromSingleNormal() {
         Completable c = Completable.fromSingle(Single.just(1));
         
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void fromSingleThrows() {
         Completable c = Completable.fromSingle(Single.error(new TestException()));
         
@@ -739,14 +739,14 @@ public void mergeNull() {
         Completable.merge((Completable[])null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeEmpty() {
         Completable c = Completable.merge();
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeSingleSource() {
         Completable c = Completable.merge(normal.completable);
         
@@ -755,14 +755,14 @@ public void mergeSingleSource() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeSingleSourceThrows() {
         Completable c = Completable.merge(error.completable);
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeMultipleSources() {
         Completable c = Completable.merge(normal.completable, normal.completable, normal.completable);
         
@@ -771,21 +771,21 @@ public void mergeMultipleSources() {
         normal.assertSubscriptions(3);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeMultipleOneThrows() {
         Completable c = Completable.merge(normal.completable, error.completable, normal.completable);
         
         c.await();
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeMultipleOneIsNull() {
         Completable c = Completable.merge(normal.completable, null);
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeIterableEmpty() {
         Completable c = Completable.merge(Collections.<Completable>emptyList());
         
@@ -797,7 +797,7 @@ public void mergeIterableNull() {
         Completable.merge((Iterable<Completable>)null);
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeIterableIteratorNull() {
         Completable c = Completable.merge(new Iterable<Completable>() {
             @Override
@@ -809,14 +809,14 @@ public Iterator<Completable> iterator() {
         c.await();
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeIterableWithNull() {
         Completable c = Completable.merge(Arrays.asList(normal.completable, (Completable)null));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeIterableSingle() {
         Completable c = Completable.merge(Collections.singleton(normal.completable));
         
@@ -825,7 +825,7 @@ public void mergeIterableSingle() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeIterableMany() {
         Completable c = Completable.merge(Arrays.asList(normal.completable, normal.completable, normal.completable));
         
@@ -834,14 +834,14 @@ public void mergeIterableMany() {
         normal.assertSubscriptions(3);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeIterableOneThrows() {
         Completable c = Completable.merge(Collections.singleton(error.completable));
         
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeIterableManyOneThrows() {
         Completable c = Completable.merge(Arrays.asList(normal.completable, error.completable));
         
@@ -874,21 +874,21 @@ public void mergeIterableIteratorNextThrows() {
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeObservableEmpty() {
         Completable c = Completable.merge(Observable.<Completable>empty());
         
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeObservableError() {
         Completable c = Completable.merge(Observable.<Completable>error(new TestException()));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeObservableSingle() {
         Completable c = Completable.merge(Observable.just(normal.completable));
         
@@ -897,14 +897,14 @@ public void mergeObservableSingle() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeObservableSingleThrows() {
         Completable c = Completable.merge(Observable.just(error.completable));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeObservableMany() {
         Completable c = Completable.merge(Observable.just(normal.completable).repeat(3));
         
@@ -913,14 +913,14 @@ public void mergeObservableMany() {
         normal.assertSubscriptions(3);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeObservableManyOneThrows() {
         Completable c = Completable.merge(Observable.just(normal.completable, error.completable));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeObservableMaxConcurrent() {
         final List<Long> requested = new ArrayList<Long>();
         Observable<Completable> cs = Observable
@@ -946,14 +946,14 @@ public void mergeDelayErrorNull() {
         Completable.mergeDelayError((Completable[])null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorEmpty() {
         Completable c = Completable.mergeDelayError();
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorSingleSource() {
         Completable c = Completable.mergeDelayError(normal.completable);
         
@@ -962,14 +962,14 @@ public void mergeDelayErrorSingleSource() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeDelayErrorSingleSourceThrows() {
         Completable c = Completable.mergeDelayError(error.completable);
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorMultipleSources() {
         Completable c = Completable.mergeDelayError(normal.completable, normal.completable, normal.completable);
         
@@ -978,7 +978,7 @@ public void mergeDelayErrorMultipleSources() {
         normal.assertSubscriptions(3);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorMultipleOneThrows() {
         Completable c = Completable.mergeDelayError(normal.completable, error.completable, normal.completable);
         
@@ -989,14 +989,14 @@ public void mergeDelayErrorMultipleOneThrows() {
         }
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeDelayErrorMultipleOneIsNull() {
         Completable c = Completable.mergeDelayError(normal.completable, null);
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorIterableEmpty() {
         Completable c = Completable.mergeDelayError(Collections.<Completable>emptyList());
         
@@ -1008,7 +1008,7 @@ public void mergeDelayErrorIterableNull() {
         Completable.mergeDelayError((Iterable<Completable>)null);
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeDelayErrorIterableIteratorNull() {
         Completable c = Completable.mergeDelayError(new Iterable<Completable>() {
             @Override
@@ -1020,14 +1020,14 @@ public Iterator<Completable> iterator() {
         c.await();
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeDelayErrorIterableWithNull() {
         Completable c = Completable.mergeDelayError(Arrays.asList(normal.completable, (Completable)null));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorIterableSingle() {
         Completable c = Completable.mergeDelayError(Collections.singleton(normal.completable));
         
@@ -1036,7 +1036,7 @@ public void mergeDelayErrorIterableSingle() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorIterableMany() {
         Completable c = Completable.mergeDelayError(Arrays.asList(normal.completable, normal.completable, normal.completable));
         
@@ -1045,14 +1045,14 @@ public void mergeDelayErrorIterableMany() {
         normal.assertSubscriptions(3);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeDelayErrorIterableOneThrows() {
         Completable c = Completable.mergeDelayError(Collections.singleton(error.completable));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorIterableManyOneThrows() {
         Completable c = Completable.mergeDelayError(Arrays.asList(normal.completable, error.completable, normal.completable));
         
@@ -1089,21 +1089,21 @@ public void mergeDelayErrorIterableIteratorNextThrows() {
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorObservableEmpty() {
         Completable c = Completable.mergeDelayError(Observable.<Completable>empty());
         
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeDelayErrorObservableError() {
         Completable c = Completable.mergeDelayError(Observable.<Completable>error(new TestException()));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorObservableSingle() {
         Completable c = Completable.mergeDelayError(Observable.just(normal.completable));
         
@@ -1112,14 +1112,14 @@ public void mergeDelayErrorObservableSingle() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeDelayErrorObservableSingleThrows() {
         Completable c = Completable.mergeDelayError(Observable.just(error.completable));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorObservableMany() {
         Completable c = Completable.mergeDelayError(Observable.just(normal.completable).repeat(3));
         
@@ -1128,14 +1128,14 @@ public void mergeDelayErrorObservableMany() {
         normal.assertSubscriptions(3);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void mergeDelayErrorObservableManyOneThrows() {
         Completable c = Completable.mergeDelayError(Observable.just(normal.completable, error.completable));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeDelayErrorObservableMaxConcurrent() {
         final List<Long> requested = new ArrayList<Long>();
         Observable<Completable> cs = Observable
@@ -1156,7 +1156,7 @@ public void call(Long v) {
         Assert.assertEquals(Arrays.asList(5L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L), requested);
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void never() {
         final AtomicBoolean onSubscribeCalled = new AtomicBoolean();
         final AtomicInteger calls = new AtomicInteger();
@@ -1195,7 +1195,7 @@ public void timerNewThread() {
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void timerTestScheduler() {
         TestScheduler scheduler = Schedulers.test();
         
@@ -1272,7 +1272,7 @@ public void timerSchedulerNull() {
         Completable.timer(1, TimeUnit.SECONDS, null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void usingNormalEager() {
         final AtomicInteger unsubscribe = new AtomicInteger();
         
@@ -1318,7 +1318,7 @@ public void onCompleted() {
         Assert.assertNull(error.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void usingNormalLazy() {
         final AtomicInteger unsubscribe = new AtomicInteger();
         
@@ -1364,7 +1364,7 @@ public void onCompleted() {
         Assert.assertNull(error.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void usingErrorEager() {
         final AtomicInteger unsubscribe = new AtomicInteger();
         
@@ -1410,7 +1410,7 @@ public void onCompleted() {
         Assert.assertFalse(complete.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void usingErrorLazy() {
         final AtomicInteger unsubscribe = new AtomicInteger();
         
@@ -1576,7 +1576,7 @@ public Completable call(Object v) {
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void composeNormal() {
         Completable c = error.completable.compose(new CompletableTransformer() {
             @Override
@@ -1593,7 +1593,7 @@ public void composeNull() {
         error.completable.compose(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void concatWithNormal() {
         Completable c = normal.completable.concatWith(normal.completable);
         
@@ -1602,7 +1602,7 @@ public void concatWithNormal() {
         normal.assertSubscriptions(2);
     }
 
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void concatWithError() {
         Completable c = normal.completable.concatWith(error.completable);
         
@@ -1624,7 +1624,7 @@ public void delaySchedulerNull() {
         normal.completable.delay(1, TimeUnit.SECONDS, null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void delayNormal() throws InterruptedException {
         Completable c = normal.completable.delay(250, TimeUnit.MILLISECONDS);
         
@@ -1659,7 +1659,7 @@ public void onCompleted() {
         Assert.assertNull(error.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void delayErrorImmediately() throws InterruptedException {
         Completable c = error.completable.delay(250, TimeUnit.MILLISECONDS);
         
@@ -1693,7 +1693,7 @@ public void onCompleted() {
         Thread.sleep(200);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void delayErrorToo() throws InterruptedException {
         Completable c = error.completable.delay(250, TimeUnit.MILLISECONDS, Schedulers.computation(), true);
         
@@ -1728,7 +1728,7 @@ public void onCompleted() {
         Assert.assertTrue(error.get() instanceof TestException);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnCompletedNormal() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -1744,7 +1744,7 @@ public void call() {
         Assert.assertEquals(1, calls.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnCompletedError() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -1770,7 +1770,7 @@ public void doOnCompletedNull() {
         normal.completable.doOnCompleted(null);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void doOnCompletedThrows() {
         Completable c = normal.completable.doOnCompleted(new Action0() {
             @Override
@@ -1780,7 +1780,7 @@ public void doOnCompletedThrows() {
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnDisposeNormalDoesntCall() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -1796,7 +1796,7 @@ public void call() {
         Assert.assertEquals(0, calls.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnDisposeErrorDoesntCall() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -1816,7 +1816,7 @@ public void call() {
         Assert.assertEquals(0, calls.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnDisposeChildCancels() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -1852,7 +1852,7 @@ public void doOnDisposeNull() {
         normal.completable.doOnUnsubscribe(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnDisposeThrows() {
         Completable c = normal.completable.doOnUnsubscribe(new Action0() {
             @Override
@@ -1877,7 +1877,7 @@ public void onCompleted() {
         });
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnErrorNoError() {
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
         
@@ -1893,7 +1893,7 @@ public void call(Throwable e) {
         Assert.assertNull(error.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnErrorHasError() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
         
@@ -1919,7 +1919,7 @@ public void doOnErrorNull() {
         normal.completable.doOnError(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnErrorThrows() {
         Completable c = error.completable.doOnError(new Action1<Throwable>() {
             @Override
@@ -1936,7 +1936,7 @@ public void doOnErrorThrows() {
         }
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnSubscribeNormal() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -1969,7 +1969,7 @@ public void doOnSubscribeThrows() {
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnTerminateNormal() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -1985,7 +1985,7 @@ public void call() {
         Assert.assertEquals(1, calls.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doOnTerminateError() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -2006,7 +2006,7 @@ public void call() {
         Assert.assertEquals(1, calls.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doAfterTerminateNormal() {
         final AtomicBoolean doneAfter = new AtomicBoolean();
         final AtomicBoolean complete = new AtomicBoolean();
@@ -2041,7 +2041,7 @@ public void onCompleted() {
         Assert.assertTrue("Closure called before onComplete", doneAfter.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void doAfterTerminateWithError() {
         final AtomicBoolean doneAfter = new AtomicBoolean();
         
@@ -2067,17 +2067,17 @@ public void doAfterTerminateNull() {
         normal.completable.doAfterTerminate(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void getNormal() {
         Assert.assertNull(normal.completable.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void getError() {
         Assert.assertTrue(error.completable.get() instanceof TestException);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void getTimeout() {
         try {
             Completable.never().get(100, TimeUnit.MILLISECONDS);
@@ -2098,7 +2098,7 @@ public void liftNull() {
         normal.completable.lift(null);
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void liftReturnsNull() {
         Completable c = normal.completable.lift(new CompletableOperator() {
             @Override
@@ -2133,14 +2133,14 @@ public void onSubscribe(Subscription d) {
             };
         }
     }
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void liftOnCompleteError() {
         Completable c = normal.completable.lift(new CompletableOperatorSwap());
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void liftOnErrorComplete() {
         Completable c = error.completable.lift(new CompletableOperatorSwap());
         
@@ -2152,7 +2152,7 @@ public void mergeWithNull() {
         normal.completable.mergeWith(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void mergeWithNormal() {
         Completable c = normal.completable.mergeWith(normal.completable);
         
@@ -2166,7 +2166,7 @@ public void observeOnNull() {
         normal.completable.observeOn(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void observeOnNormal() throws InterruptedException {
         final AtomicReference<String> name = new AtomicReference<String>();
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
@@ -2199,7 +2199,7 @@ public void onError(Throwable e) {
         Assert.assertTrue(name.get().startsWith("RxComputation"));
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void observeOnError() throws InterruptedException {
         final AtomicReference<String> name = new AtomicReference<String>();
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
@@ -2233,14 +2233,14 @@ public void onError(Throwable e) {
         Assert.assertTrue(name.get().startsWith("RxComputation"));
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void onErrorComplete() {
         Completable c = error.completable.onErrorComplete();
         
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void onErrorCompleteFalse() {
         Completable c = error.completable.onErrorComplete(new Func1<Throwable, Boolean>() {
             @Override
@@ -2262,7 +2262,7 @@ public void onErrorResumeNextNull() {
         error.completable.onErrorResumeNext(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void onErrorResumeNextFunctionReturnsNull() {
         Completable c = error.completable.onErrorResumeNext(new Func1<Throwable, Completable>() {
             @Override
@@ -2282,7 +2282,7 @@ public Completable call(Throwable e) {
         }
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void onErrorResumeNextFunctionThrows() {
         Completable c = error.completable.onErrorResumeNext(new Func1<Throwable, Completable>() {
             @Override
@@ -2300,7 +2300,7 @@ public void onErrorResumeNextFunctionThrows() {
         }
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void onErrorResumeNextNormal() {
         Completable c = error.completable.onErrorResumeNext(new Func1<Throwable, Completable>() {
             @Override
@@ -2312,7 +2312,7 @@ public Completable call(Throwable v) {
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void onErrorResumeNextError() {
         Completable c = error.completable.onErrorResumeNext(new Func1<Throwable, Completable>() {
             @Override
@@ -2369,14 +2369,14 @@ public void onCompleted() {
         Assert.assertNull(err.get());
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void repeatError() {
         Completable c = error.completable.repeat();
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void repeat5Times() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -2393,7 +2393,7 @@ public Object call() throws Exception {
         Assert.assertEquals(5, calls.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void repeat1Time() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -2410,7 +2410,7 @@ public Object call() throws Exception {
         Assert.assertEquals(1, calls.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void repeat0Time() {
         final AtomicInteger calls = new AtomicInteger();
         
@@ -2432,7 +2432,7 @@ public void repeatWhenNull() {
         normal.completable.repeatWhen(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void retryNormal() {
         Completable c = normal.completable.retry();
         
@@ -2441,7 +2441,7 @@ public void retryNormal() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void retry5Times() {
         final AtomicInteger calls = new AtomicInteger(5);
         
@@ -2457,7 +2457,7 @@ public void call() {
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void retryBiPredicate5Times() {
         Completable c = error.completable.retry(new Func2<Integer, Throwable, Boolean>() {
             @Override
@@ -2469,14 +2469,14 @@ public Boolean call(Integer n, Throwable e) {
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void retryTimes5Error() {
         Completable c = error.completable.retry(5);
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void retryTimes5Normal() {
         final AtomicInteger calls = new AtomicInteger(5);
 
@@ -2497,7 +2497,7 @@ public void retryNegativeTimes() {
         normal.completable.retry(-1);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void retryWhen5Times() {
         final AtomicInteger calls = new AtomicInteger(5);
 
@@ -2519,7 +2519,7 @@ public Observable<Object> call(Observable<? extends Throwable> o) {
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribe() throws InterruptedException {
         final AtomicBoolean complete = new AtomicBoolean();
         
@@ -2539,7 +2539,7 @@ public void call() {
         Assert.assertTrue("Not completed", complete.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribeDispose() throws InterruptedException {
         final AtomicBoolean complete = new AtomicBoolean();
         
@@ -2563,7 +2563,7 @@ public void call() {
         Assert.assertFalse("Completed", complete.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribeTwoCallbacksNormal() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
         final AtomicBoolean complete = new AtomicBoolean();
@@ -2583,7 +2583,7 @@ public void call() {
         Assert.assertTrue("Not completed", complete.get());
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribeTwoCallbacksError() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
         final AtomicBoolean complete = new AtomicBoolean();
@@ -2619,7 +2619,7 @@ public void call() { }
         });
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribeTwoCallbacksCompleteThrows() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
         normal.completable.subscribe(new Action1<Throwable>() {
@@ -2635,7 +2635,7 @@ public void call(Throwable e) {
         Assert.assertTrue(String.valueOf(err.get()), err.get() instanceof TestException);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribeTwoCallbacksOnErrorThrows() {
         error.completable.subscribe(new Action1<Throwable>() {
             @Override
@@ -2646,7 +2646,7 @@ public void call() { }
         });
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribeActionNormal() {
         final AtomicBoolean run = new AtomicBoolean();
         
@@ -2660,7 +2660,7 @@ public void call() {
         Assert.assertTrue("Not completed", run.get());
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribeActionError() {
         final AtomicBoolean run = new AtomicBoolean();
         
@@ -2689,7 +2689,7 @@ public void subscribeCompletableSubscriberNull() {
         normal.completable.unsafeSubscribe((CompletableSubscriber)null);
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribeSubscriberNormal() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
         
@@ -2700,7 +2700,7 @@ public void subscribeSubscriberNormal() {
         ts.assertNoErrors();
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribeSubscriberError() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
         
@@ -2716,7 +2716,7 @@ public void subscribeOnNull() {
         normal.completable.subscribeOn(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribeOnNormal() {
         final AtomicReference<String> name = new  AtomicReference<String>();
         
@@ -2734,7 +2734,7 @@ public void call(CompletableSubscriber s) {
         Assert.assertTrue(name.get().startsWith("RxComputation"));
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void subscribeOnError() {
         final AtomicReference<String> name = new  AtomicReference<String>();
         
@@ -2838,14 +2838,14 @@ public void call(Integer integer) {
         });
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void timeoutEmitError() {
         Throwable e = Completable.never().timeout(100, TimeUnit.MILLISECONDS).get();
         
         Assert.assertTrue(e instanceof TimeoutException);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void timeoutSwitchNormal() {
         Completable c = Completable.never().timeout(100, TimeUnit.MILLISECONDS, normal.completable);
         
@@ -2854,7 +2854,7 @@ public void timeoutSwitchNormal() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void timeoutTimerCancelled() throws InterruptedException {
         Completable c = Completable.fromCallable(new Callable<Object>() {
             @Override
@@ -2886,7 +2886,7 @@ public void timeoutOtherNull() {
         normal.completable.timeout(1, TimeUnit.SECONDS, (Completable)null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void toNormal() {
         Observable<?> flow = normal.completable.to(new Func1<Completable, Observable<Object>>() {
             @Override
@@ -2906,7 +2906,7 @@ public void toNull() {
         normal.completable.to(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void toObservableNormal() {
         normal.completable.toObservable().toBlocking().forEach(new Action1<Object>() {
             @Override
@@ -2914,7 +2914,7 @@ public void call(Object e) { }
         });
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void toObservableError() {
         error.completable.toObservable().toBlocking().forEach(new Action1<Object>() {
             @Override
@@ -2955,7 +2955,7 @@ public void onError(Throwable error) {
         return v.get();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void toSingleSupplierNormal() {
         int v = get(normal.completable.toSingle(new Func0<Integer>() {
             @Override
@@ -2967,7 +2967,7 @@ public Integer call() {
         Assert.assertEquals(1, v);
     }
 
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void toSingleSupplierError() {
         get(error.completable.toSingle(new Func0<Object>() {
             @Override
@@ -3000,12 +3000,12 @@ public void toSingleSupplierThrows() {
         }));
     }
 
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void toSingleDefaultError() {
         get(error.completable.toSingleDefault(1));
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void toSingleDefaultNormal() {
         Assert.assertEquals((Integer)1, get(normal.completable.toSingleDefault(1)));
     }
@@ -3015,7 +3015,7 @@ public void toSingleDefaultNull() {
         normal.completable.toSingleDefault(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void unsubscribeOnNormal() throws InterruptedException {
         final AtomicReference<String> name = new AtomicReference<String>();
         final CountDownLatch cdl = new CountDownLatch(1);
@@ -3067,28 +3067,28 @@ public void ambArrayNull() {
         Completable.amb((Completable[])null);
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambArrayEmpty() {
         Completable c = Completable.amb();
                 
         c.await();
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambArraySingleNormal() {
         Completable c = Completable.amb(normal.completable);
                 
         c.await();
     }
 
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void ambArraySingleError() {
         Completable c = Completable.amb(error.completable);
                 
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambArrayOneFires() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
@@ -3119,7 +3119,7 @@ public void call() {
         Assert.assertTrue("Not completed", complete.get());
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambArrayOneFiresError() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
@@ -3153,7 +3153,7 @@ public void call() { }
         Assert.assertTrue("Not completed", complete.get() instanceof TestException);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambArraySecondFires() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
@@ -3184,7 +3184,7 @@ public void call() {
         Assert.assertTrue("Not completed", complete.get());
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambArraySecondFiresError() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
@@ -3218,14 +3218,14 @@ public void call() { }
         Assert.assertTrue("Not completed", complete.get() instanceof TestException);
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void ambMultipleOneIsNull() {
         Completable c = Completable.amb(null, normal.completable);
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambIterableEmpty() {
         Completable c = Completable.amb(Collections.<Completable>emptyList());
         
@@ -3237,7 +3237,7 @@ public void ambIterableNull() {
         Completable.amb((Iterable<Completable>)null);
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void ambIterableIteratorNull() {
         Completable c = Completable.amb(new Iterable<Completable>() {
             @Override
@@ -3249,14 +3249,14 @@ public Iterator<Completable> iterator() {
         c.await();
     }
     
-    @Test(timeout = 1000, expected = NullPointerException.class)
+    @Test(timeout = 5000, expected = NullPointerException.class)
     public void ambIterableWithNull() {
         Completable c = Completable.amb(Arrays.asList(null, normal.completable));
         
         c.await();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambIterableSingle() {
         Completable c = Completable.amb(Collections.singleton(normal.completable));
         
@@ -3265,7 +3265,7 @@ public void ambIterableSingle() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambIterableMany() {
         Completable c = Completable.amb(Arrays.asList(normal.completable, normal.completable, normal.completable));
         
@@ -3274,14 +3274,14 @@ public void ambIterableMany() {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void ambIterableOneThrows() {
         Completable c = Completable.amb(Collections.singleton(error.completable));
         
         c.await();
     }
     
-    @Test(timeout = 1000, expected = TestException.class)
+    @Test(timeout = 5000, expected = TestException.class)
     public void ambIterableManyOneThrows() {
         Completable c = Completable.amb(Arrays.asList(error.completable, normal.completable));
         
@@ -3319,7 +3319,7 @@ public void ambWithNull() {
         normal.completable.ambWith(null);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambWithArrayOneFires() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
@@ -3350,7 +3350,7 @@ public void call() {
         Assert.assertTrue("Not completed", complete.get());
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambWithArrayOneFiresError() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
@@ -3384,7 +3384,7 @@ public void call() { }
         Assert.assertTrue("Not completed", complete.get() instanceof TestException);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambWithArraySecondFires() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
@@ -3415,7 +3415,7 @@ public void call() {
         Assert.assertTrue("Not completed", complete.get());
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void ambWithArraySecondFiresError() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
@@ -3449,7 +3449,7 @@ public void call() { }
         Assert.assertTrue("Not completed", complete.get() instanceof TestException);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void startWithCompletableNormal() {
         final AtomicBoolean run = new AtomicBoolean();
         Completable c = normal.completable
@@ -3467,7 +3467,7 @@ public Object call() throws Exception {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void startWithCompletableError() {
         Completable c = normal.completable.startWith(error.completable);
         
@@ -3480,7 +3480,7 @@ public void startWithCompletableError() {
         }
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void startWithFlowableNormal() {
         final AtomicBoolean run = new AtomicBoolean();
         Observable<Object> c = normal.completable
@@ -3504,7 +3504,7 @@ public Object call() throws Exception {
         ts.assertNoErrors();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void startWithFlowableError() {
         Observable<Object> c = normal.completable
                 .startWith(Observable.error(new TestException()));
@@ -3540,7 +3540,7 @@ public void andThenFlowableNull() {
         normal.completable.andThen((Observable<Object>)null);
     }
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void andThenCompletableNormal() {
         final AtomicBoolean run = new AtomicBoolean();
         Completable c = normal.completable
@@ -3558,7 +3558,7 @@ public Object call() throws Exception {
         normal.assertSubscriptions(1);
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void andThenCompletableError() {
         Completable c = normal.completable.andThen(error.completable);
         
@@ -3571,7 +3571,7 @@ public void andThenCompletableError() {
         }
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void andThenFlowableNormal() {
         final AtomicBoolean run = new AtomicBoolean();
         Observable<Object> c = normal.completable
@@ -3595,7 +3595,7 @@ public Object call() throws Exception {
         ts.assertNoErrors();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void andThenFlowableError() {
         Observable<Object> c = normal.completable
                 .andThen(Observable.error(new TestException()));
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
index 743a8b3b09..4b44f5d739 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
@@ -268,36 +268,40 @@ public void run() {
 
         });
 
-        Iterator<Integer> it = next(obs).iterator();
-
-        assertTrue(it.hasNext());
-        int a = it.next();
-        assertTrue(it.hasNext());
-        int b = it.next();
-        // we should have a different value
-        assertTrue("a and b should be different", a != b);
-
-        // wait for some time (if times out we are blocked somewhere so fail ... set very high for very slow, constrained machines)
-        timeHasPassed.await(8000, TimeUnit.MILLISECONDS);
-
-        assertTrue(it.hasNext());
-        int c = it.next();
-
-        assertTrue("c should not just be the next in sequence", c != (b + 1));
-        assertTrue("expected that c [" + c + "] is higher than or equal to " + COUNT, c >= COUNT);
-
-        assertTrue(it.hasNext());
-        int d = it.next();
-        assertTrue(d > c);
-
-        // shut down the thread
-        running.set(false);
-
-        finished.await();
-
-        assertFalse(it.hasNext());
-
-        System.out.println("a: " + a + " b: " + b + " c: " + c);
+        try {
+            Iterator<Integer> it = next(obs).iterator();
+    
+            assertTrue(it.hasNext());
+            int a = it.next();
+            assertTrue(it.hasNext());
+            int b = it.next();
+            // we should have a different value
+            assertTrue("a and b should be different", a != b);
+    
+            // wait for some time (if times out we are blocked somewhere so fail ... set very high for very slow, constrained machines)
+            timeHasPassed.await(8000, TimeUnit.MILLISECONDS);
+    
+            assertTrue(it.hasNext());
+            int c = it.next();
+    
+            assertTrue("c should not just be the next in sequence", c != (b + 1));
+            assertTrue("expected that c [" + c + "] is higher than or equal to " + COUNT, c >= COUNT);
+    
+            assertTrue(it.hasNext());
+            int d = it.next();
+            assertTrue(d > c);
+    
+            // shut down the thread
+            running.set(false);
+    
+            finished.await();
+    
+            assertFalse(it.hasNext());
+    
+            System.out.println("a: " + a + " b: " + b + " c: " + c);
+        } finally {
+            running.set(false); // don't let the thread spin indefinitely
+        }
     }
 
     @Test /* (timeout = 8000) */
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchTest.java b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
index c1fcf8d534..a908ec10cf 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
@@ -854,7 +854,7 @@ public void onNext(Integer t) {
                 }
             };
             
-            Observable.range(1, 25000)
+            Observable.range(1, 10000)
             .observeOn(Schedulers.computation(), i)
             .switchMap(new Func1<Integer, Observable<Integer>>() {
                 @Override

From 5be3a4b12f2a72fe194d347d6518f42a2920f61a Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 25 Jun 2016 07:42:36 +0200
Subject: [PATCH 079/263] 1.x: apply fixes based on PMD suggestions (#4091)

* 1.x: apply fixes based on PMD suggestions

* InternalError(Throwable cause) is not available

* Remove private from inner (static) classes, add final where needed

* Remove by akarnokd, update rules
---
 pmd.xml                                       |  7 --
 src/main/java/rx/BackpressureOverflow.java    | 32 ++++++--
 src/main/java/rx/Completable.java             | 47 ++++++------
 src/main/java/rx/Notification.java            | 27 +++----
 src/main/java/rx/Observable.java              | 11 +--
 src/main/java/rx/Single.java                  | 14 ++--
 .../AssemblyStackTraceException.java          |  2 +-
 .../rx/exceptions/CompositeException.java     | 48 ++++++------
 src/main/java/rx/exceptions/Exceptions.java   | 11 +--
 .../MissingBackpressureException.java         |  2 +-
 .../java/rx/exceptions/OnErrorThrowable.java  |  8 +-
 src/main/java/rx/functions/Actions.java       | 21 ++++--
 src/main/java/rx/functions/Functions.java     | 28 +++----
 .../internal/operators/BackpressureUtils.java | 18 ++---
 .../operators/BlockingOperatorLatest.java     |  5 +-
 .../operators/BlockingOperatorMostRecent.java | 10 ++-
 .../operators/BlockingOperatorNext.java       | 11 +--
 .../operators/BlockingOperatorToFuture.java   |  2 +-
 .../operators/BufferUntilSubscriber.java      | 21 +++---
 ...bleOnSubscribeMergeDelayErrorIterable.java |  7 +-
 .../CompletableOnSubscribeMergeIterable.java  |  7 +-
 .../operators/EmptyObservableHolder.java      |  7 +-
 .../operators/NeverObservableHolder.java      |  9 ++-
 .../internal/operators/NotificationLite.java  | 26 ++++---
 .../rx/internal/operators/OnSubscribeAmb.java | 13 ++--
 .../operators/OnSubscribeCombineLatest.java   | 12 +--
 .../operators/OnSubscribeFromIterable.java    |  2 +-
 .../operators/OnSubscribeGroupJoin.java       | 14 ++--
 .../internal/operators/OnSubscribeRange.java  |  2 +-
 .../internal/operators/OnSubscribeRedo.java   | 30 ++++----
 .../internal/operators/OnSubscribeSingle.java |  6 +-
 .../internal/operators/OnSubscribeUsing.java  | 11 +--
 .../operators/OperatorAsObservable.java       |  7 +-
 .../operators/OperatorDebounceWithTime.java   |  4 +-
 .../operators/OperatorDematerialize.java      | 10 ++-
 .../internal/operators/OperatorDistinct.java  |  2 +-
 .../OperatorDistinctUntilChanged.java         |  6 +-
 .../internal/operators/OperatorDoOnEach.java  |  2 +-
 .../operators/OperatorDoOnRequest.java        |  2 +-
 .../operators/OperatorEagerConcatMap.java     | 18 ++---
 .../internal/operators/OperatorElementAt.java |  2 +-
 .../internal/operators/OperatorGroupBy.java   | 30 ++++----
 .../operators/OperatorIgnoreElements.java     |  4 +-
 .../internal/operators/OperatorMapPair.java   |  5 +-
 .../operators/OperatorMaterialize.java        |  9 ++-
 .../rx/internal/operators/OperatorMerge.java  | 14 ++--
 .../internal/operators/OperatorMulticast.java |  6 +-
 .../internal/operators/OperatorObserveOn.java |  2 +-
 .../OperatorOnBackpressureBuffer.java         | 13 ++--
 .../operators/OperatorOnBackpressureDrop.java |  6 +-
 .../internal/operators/OperatorPublish.java   |  4 +-
 .../rx/internal/operators/OperatorReplay.java | 33 ++++-----
 .../rx/internal/operators/OperatorScan.java   | 10 +--
 .../operators/OperatorSequenceEqual.java      |  6 +-
 .../internal/operators/OperatorSerialize.java |  8 +-
 .../rx/internal/operators/OperatorSingle.java |  4 +-
 .../rx/internal/operators/OperatorSkip.java   |  2 +-
 .../internal/operators/OperatorSkipWhile.java |  2 +-
 .../rx/internal/operators/OperatorSwitch.java | 11 ++-
 .../operators/OperatorSwitchIfEmpty.java      |  4 +-
 .../rx/internal/operators/OperatorTake.java   |  4 +-
 .../operators/OperatorTakeLastOne.java        | 15 ++--
 .../operators/OperatorTakeUntilPredicate.java | 45 ++++++-----
 .../internal/operators/OperatorTakeWhile.java |  4 +-
 .../operators/OperatorThrottleFirst.java      |  2 +-
 .../operators/OperatorTimeoutBase.java        |  9 +--
 .../rx/internal/operators/OperatorToMap.java  | 14 ++--
 .../operators/OperatorToMultimap.java         | 11 +--
 .../operators/OperatorToObservableList.java   |  9 ++-
 .../OperatorToObservableSortedList.java       | 10 +--
 .../OperatorWindowWithObservable.java         | 22 +++---
 .../OperatorWindowWithObservableFactory.java  | 23 +++---
 .../OperatorWindowWithStartEndObservable.java |  2 +-
 .../operators/OperatorWindowWithTime.java     | 20 ++---
 .../operators/OperatorWithLatestFromMany.java |  2 +-
 .../rx/internal/operators/OperatorZip.java    | 13 ++--
 .../operators/SingleOnSubscribeUsing.java     |  2 +-
 .../SingleOperatorOnErrorResumeNext.java      |  2 +-
 .../internal/operators/SingleOperatorZip.java |  7 +-
 .../internal/producers/ProducerArbiter.java   |  2 +-
 .../producers/ProducerObserverArbiter.java    |  2 +-
 .../producers/SingleDelayedProducer.java      |  4 +-
 .../rx/internal/producers/SingleProducer.java |  2 +-
 .../schedulers/CachedThreadScheduler.java     | 25 ++++---
 .../schedulers/EventLoopsScheduler.java       | 14 ++--
 .../schedulers/ImmediateScheduler.java        |  4 +-
 .../internal/schedulers/NewThreadWorker.java  | 34 +++++----
 .../internal/schedulers/ScheduledAction.java  | 25 +++----
 .../internal/schedulers/SleepingAction.java   |  3 +-
 .../schedulers/TrampolineScheduler.java       |  7 +-
 .../util/BackpressureDrainManager.java        | 34 ++++-----
 .../java/rx/internal/util/BlockingUtils.java  |  2 +-
 .../java/rx/internal/util/FrontPadding.java   | 31 --------
 .../rx/internal/util/IndexedRingBuffer.java   | 51 ++++++-------
 .../util/InternalObservableUtils.java         | 51 +++++++------
 .../rx/internal/util/LinkedArrayList.java     |  4 +-
 .../java/rx/internal/util/ObjectPool.java     |  2 +-
 .../java/rx/internal/util/OpenHashSet.java    |  7 +-
 .../rx/internal/util/PlatformDependent.java   |  7 +-
 .../rx/internal/util/RxJavaPluginUtils.java   |  9 ++-
 .../java/rx/internal/util/RxRingBuffer.java   | 70 +++++++++---------
 .../util/ScalarSynchronousObservable.java     |  8 +-
 .../util/ScalarSynchronousSingle.java         |  7 +-
 .../rx/internal/util/SubscriptionList.java    | 18 ++++-
 .../rx/internal/util/SynchronizedQueue.java   | 59 ++++++++-------
 .../util/SynchronizedSubscription.java        | 35 ---------
 .../rx/internal/util/UtilityFunctions.java    | 14 ++--
 .../atomic/AtomicReferenceArrayQueue.java     |  3 +-
 .../util/atomic/BaseLinkedAtomicQueue.java    |  2 +-
 .../internal/util/atomic/LinkedQueueNode.java |  2 +
 .../util/atomic/MpscLinkedAtomicQueue.java    | 10 +--
 .../util/atomic/SpscAtomicArrayQueue.java     |  2 +-
 .../atomic/SpscExactAtomicArrayQueue.java     |  2 +-
 .../util/atomic/SpscLinkedArrayQueue.java     | 29 ++++----
 .../atomic/SpscUnboundedAtomicArrayQueue.java | 24 +++---
 .../internal/util/unsafe/BaseLinkedQueue.java |  2 +-
 .../unsafe/ConcurrentCircularArrayQueue.java  |  3 +-
 .../internal/util/unsafe/MpscLinkedQueue.java | 12 +--
 .../util/unsafe/QueueProgressIndicators.java  |  4 +-
 .../internal/util/unsafe/SpmcArrayQueue.java  |  2 +-
 .../util/unsafe/SpscUnboundedArrayQueue.java  |  8 +-
 .../rx/internal/util/unsafe/UnsafeAccess.java | 18 +++--
 .../java/rx/observables/AsyncOnSubscribe.java | 14 ++--
 .../rx/observables/BlockingObservable.java    | 40 ++++------
 .../java/rx/observables/SyncOnSubscribe.java  | 18 +++--
 .../observers/AsyncCompletableSubscriber.java | 10 +--
 .../java/rx/observers/SafeSubscriber.java     | 74 +++++++++----------
 src/main/java/rx/observers/TestObserver.java  | 33 ++++-----
 .../java/rx/observers/TestSubscriber.java     | 31 ++++----
 .../RxJavaCompletableExecutionHook.java       |  2 +-
 .../java/rx/plugins/RxJavaErrorHandler.java   |  6 +-
 src/main/java/rx/plugins/RxJavaHooks.java     | 11 +--
 .../RxJavaObservableExecutionHook.java        |  2 +-
 .../RxJavaObservableExecutionHookDefault.java |  9 ++-
 src/main/java/rx/plugins/RxJavaPlugins.java   | 24 +++---
 .../java/rx/plugins/RxJavaSchedulersHook.java | 20 ++---
 .../rx/plugins/RxJavaSingleExecutionHook.java |  2 +-
 .../RxJavaSingleExecutionHookDefault.java     |  8 +-
 .../rx/schedulers/ImmediateScheduler.java     |  2 +-
 .../rx/schedulers/NewThreadScheduler.java     |  2 +-
 src/main/java/rx/schedulers/Schedulers.java   |  6 +-
 .../java/rx/schedulers/TestScheduler.java     | 20 ++---
 src/main/java/rx/schedulers/TimeInterval.java | 20 +++--
 src/main/java/rx/schedulers/Timestamped.java  |  2 +-
 .../rx/schedulers/TrampolineScheduler.java    |  2 +-
 src/main/java/rx/singles/BlockingSingle.java  |  9 +--
 src/main/java/rx/subjects/AsyncSubject.java   |  7 +-
 .../java/rx/subjects/BehaviorSubject.java     | 11 ++-
 src/main/java/rx/subjects/PublishSubject.java |  5 +-
 src/main/java/rx/subjects/ReplaySubject.java  | 10 +--
 .../subjects/SubjectSubscriptionManager.java  | 12 +--
 src/main/java/rx/subjects/TestSubject.java    | 18 ++---
 src/main/java/rx/subjects/UnicastSubject.java |  4 +-
 .../rx/subscriptions/BooleanSubscription.java |  4 +-
 .../subscriptions/CompositeSubscription.java  |  4 +
 .../MultipleAssignmentSubscription.java       |  2 +-
 .../subscriptions/RefCountSubscription.java   |  4 +-
 .../rx/subscriptions/SerialSubscription.java  |  2 +-
 .../java/rx/subscriptions/Subscriptions.java  | 12 +--
 .../rx/observables/SyncOnSubscribePerf.java   |  2 +-
 .../operators/OperatorSubscribeOnTest.java    |  2 +-
 .../java/rx/util/AssertObservableTest.java    | 20 +++--
 162 files changed, 1040 insertions(+), 1013 deletions(-)
 delete mode 100644 src/main/java/rx/internal/util/FrontPadding.java
 delete mode 100644 src/main/java/rx/internal/util/SynchronizedSubscription.java

diff --git a/pmd.xml b/pmd.xml
index e6fbccdd95..339af7d5ac 100644
--- a/pmd.xml
+++ b/pmd.xml
@@ -71,7 +71,6 @@
    <rule ref="rulesets/java/basic.xml/DontUseFloatTypeForLoopIndices"/>
    <rule ref="rulesets/java/basic.xml/DoubleCheckedLocking"/>
    <rule ref="rulesets/java/imports.xml/DuplicateImports"/>
-   <rule ref="rulesets/java/empty.xml/EmptyCatchBlock"/>
    <rule ref="rulesets/java/finalizers.xml/EmptyFinalizer"/>
    <rule ref="rulesets/java/empty.xml/EmptyFinallyBlock"/>
    <rule ref="rulesets/java/empty.xml/EmptyInitializer"/>
@@ -134,9 +133,6 @@
    <rule ref="rulesets/java/javabeans.xml/MissingSerialVersionUID"/>
    <rule ref="rulesets/java/design.xml/MissingStaticMethodInNonInstantiatableClass"/>
    <rule ref="rulesets/java/logging-java.xml/MoreThanOneLogger"/>
-   <rule ref="rulesets/java/codesize.xml/NcssConstructorCount"/>
-   <rule ref="rulesets/java/codesize.xml/NcssMethodCount"/>
-   <rule ref="rulesets/java/codesize.xml/NcssTypeCount"/>
    <rule ref="rulesets/java/naming.xml/NoPackage"/>
    <rule ref="rulesets/java/design.xml/NonCaseLabelInSwitchStatement"/>
    <rule ref="rulesets/java/design.xml/NonStaticInitializer"/>
@@ -160,7 +156,6 @@
    <rule ref="rulesets/java/design.xml/ReturnEmptyArrayRatherThanNull"/>
    <rule ref="rulesets/java/basic.xml/ReturnFromFinallyBlock"/>
    <rule ref="rulesets/java/migrating.xml/ShortInstantiation"/>
-   <rule ref="rulesets/java/naming.xml/ShortMethodName"/>
    <rule ref="rulesets/java/strictexception.xml/SignatureDeclareThrowsException"/>
    <rule ref="rulesets/java/design.xml/SimpleDateFormatNeedsLocale"/>
    <rule ref="rulesets/java/junit.xml/SimplifyBooleanAssertion"/>
@@ -183,8 +178,6 @@
    <rule ref="rulesets/java/junit.xml/TestClassWithoutTestCases"/>
    <rule ref="rulesets/java/design.xml/TooFewBranchesForASwitchStatement"/>
    <rule ref="rulesets/java/imports.xml/TooManyStaticImports"/>
-   <rule ref="rulesets/java/design.xml/UncommentedEmptyConstructor"/>
-   <rule ref="rulesets/java/design.xml/UncommentedEmptyMethodBody"/>
    <rule ref="rulesets/java/basic.xml/UnconditionalIfStatement"/>
    <rule ref="rulesets/java/junit.xml/UnnecessaryBooleanAssertion"/>
    <rule ref="rulesets/java/strings.xml/UnnecessaryCaseChange"/>
diff --git a/src/main/java/rx/BackpressureOverflow.java b/src/main/java/rx/BackpressureOverflow.java
index 761a2c4a80..ebd98e1b82 100644
--- a/src/main/java/rx/BackpressureOverflow.java
+++ b/src/main/java/rx/BackpressureOverflow.java
@@ -24,6 +24,30 @@
 @Experimental
 public final class BackpressureOverflow {
 
+    /**
+     * Signal a MissingBackressureException due to lack of requests.
+     */
+    public static final BackpressureOverflow.Strategy ON_OVERFLOW_ERROR = Error.INSTANCE;
+
+    /**
+     * By default, signal a MissingBackressureException due to lack of requests.
+     */
+    public static final BackpressureOverflow.Strategy ON_OVERFLOW_DEFAULT = ON_OVERFLOW_ERROR;
+
+    /**
+     * Drop the oldest value in the buffer.
+     */
+    public static final BackpressureOverflow.Strategy ON_OVERFLOW_DROP_OLDEST = DropOldest.INSTANCE;
+
+    /**
+     * Drop the latest value.
+     */
+    public static final BackpressureOverflow.Strategy ON_OVERFLOW_DROP_LATEST = DropLatest.INSTANCE;
+
+    /**
+     * Represents a callback called when a value is about to be dropped
+     * due to lack of downstream requests.
+     */
     public interface Strategy {
 
         /**
@@ -36,14 +60,6 @@ public interface Strategy {
         boolean mayAttemptDrop() throws MissingBackpressureException;
     }
 
-    public static final BackpressureOverflow.Strategy ON_OVERFLOW_DEFAULT = Error.INSTANCE;
-
-    public static final BackpressureOverflow.Strategy ON_OVERFLOW_ERROR = Error.INSTANCE;
-
-    public static final BackpressureOverflow.Strategy ON_OVERFLOW_DROP_OLDEST = DropOldest.INSTANCE;
-
-    public static final BackpressureOverflow.Strategy ON_OVERFLOW_DROP_LATEST = DropLatest.INSTANCE;
-
     /**
      * Drop oldest items from the buffer making room for newer ones.
      */
diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index e5f7c4a068..c4560cbede 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -38,6 +38,8 @@
  */
 @Experimental
 public class Completable {
+    /** The actual subscription action. */
+    private final CompletableOnSubscribe onSubscribe;
     /**
      * Callback used for building deferred computations that takes a CompletableSubscriber.
      */
@@ -192,6 +194,22 @@ public void call(final CompletableSubscriber s) {
                 final CompositeSubscription set = new CompositeSubscription();
                 s.onSubscribe(set);
 
+                Iterator<? extends Completable> it;
+                
+                try {
+                    it = sources.iterator();
+                } catch (Throwable e) {
+                    s.onError(e);
+                    return;
+                }
+                
+                if (it == null) {
+                    s.onError(new NullPointerException("The iterator returned is null"));
+                    return;
+                }
+                
+                boolean empty = true;
+                
                 final AtomicBoolean once = new AtomicBoolean();
                 
                 CompletableSubscriber inner = new CompletableSubscriber() {
@@ -220,22 +238,6 @@ public void onSubscribe(Subscription d) {
                     
                 };
                 
-                Iterator<? extends Completable> it;
-                
-                try {
-                    it = sources.iterator();
-                } catch (Throwable e) {
-                    s.onError(e);
-                    return;
-                }
-                
-                if (it == null) {
-                    s.onError(new NullPointerException("The iterator returned is null"));
-                    return;
-                }
-                
-                boolean empty = true;
-                
                 for (;;) {
                     if (once.get() || set.isUnsubscribed()) {
                         return;
@@ -377,7 +379,7 @@ public static Completable create(CompletableOnSubscribe onSubscribe) {
         requireNonNull(onSubscribe);
         try {
             return new Completable(onSubscribe);
-        } catch (NullPointerException ex) {
+        } catch (NullPointerException ex) { // NOPMD 
             throw ex;
         } catch (Throwable ex) {
             RxJavaHooks.onError(ex);
@@ -849,7 +851,7 @@ public static <R> Completable using(final Func0<R> resourceFunc0,
         return create(new CompletableOnSubscribe() {
             @Override
             public void call(final CompletableSubscriber s) {
-                final R resource;
+                final R resource; // NOPMD 
                 
                 try {
                     resource = resourceFunc0.call();
@@ -965,9 +967,6 @@ public void call() {
         });
     }
     
-    /** The actual subscription action. */
-    private final CompletableOnSubscribe onSubscribe;
-    
     /**
      * Constructs a Completable instance with the given onSubscribe callback.
      * @param onSubscribe the callback that will receive CompletableSubscribers when they subscribe,
@@ -1550,7 +1549,7 @@ public void call(CompletableSubscriber s) {
                     CompletableSubscriber sw = onLiftDecorated.call(s);
                     
                     unsafeSubscribe(sw);
-                } catch (NullPointerException ex) {
+                } catch (NullPointerException ex) { // NOPMD 
                     throw ex;
                 } catch (Throwable ex) {
                     throw toNpe(ex);
@@ -2008,7 +2007,7 @@ public final void unsafeSubscribe(CompletableSubscriber s) {
             CompletableOnSubscribe onSubscribeDecorated = RxJavaHooks.onCompletableStart(this, this.onSubscribe);
             
             onSubscribeDecorated.call(s);
-        } catch (NullPointerException ex) {
+        } catch (NullPointerException ex) { // NOPMD 
             throw ex;
         } catch (Throwable ex) {
             Exceptions.throwIfFatal(ex);
@@ -2072,7 +2071,7 @@ public void onSubscribe(Subscription d) {
                 }
             });
             RxJavaHooks.onObservableReturn(s);
-        } catch (NullPointerException ex) {
+        } catch (NullPointerException ex) { // NOPMD 
             throw ex;
         } catch (Throwable ex) {
             Exceptions.throwIfFatal(ex);
diff --git a/src/main/java/rx/Notification.java b/src/main/java/rx/Notification.java
index 71fb95c745..f1cfdab4ef 100644
--- a/src/main/java/rx/Notification.java
+++ b/src/main/java/rx/Notification.java
@@ -182,22 +182,27 @@ public enum Kind {
 
     @Override
     public String toString() {
-        StringBuilder str = new StringBuilder("[").append(super.toString()).append(" ").append(getKind());
-        if (hasValue())
-            str.append(" ").append(getValue());
-        if (hasThrowable())
-            str.append(" ").append(getThrowable().getMessage());
-        str.append("]");
+        StringBuilder str = new StringBuilder(64).append('[').append(super.toString())
+                .append(' ').append(getKind());
+        if (hasValue()) {
+            str.append(' ').append(getValue());
+        }
+        if (hasThrowable()) {
+            str.append(' ').append(getThrowable().getMessage());
+        }
+        str.append(']');
         return str.toString();
     }
 
     @Override
     public int hashCode() {
         int hash = getKind().hashCode();
-        if (hasValue())
+        if (hasValue()) {
             hash = hash * 31 + getValue().hashCode();
-        if (hasThrowable())
+        }
+        if (hasThrowable()) {
             hash = hash * 31 + getThrowable().hashCode();
+        }
         return hash;
     }
 
@@ -224,10 +229,6 @@ public boolean equals(Object obj) {
             return false;
         }
 
-        if (!(throwable == notification.throwable || (throwable != null && throwable.equals(notification.throwable)))) {
-            return false;
-        }
-
-        return true;
+        return (throwable == notification.throwable || (throwable != null && throwable.equals(notification.throwable)));
     }
 }
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 4507c4480f..4599edb5f4 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -9015,7 +9015,7 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
                 // TODO could the hook be the cause of the error in the on error handling.
                 RxJavaHooks.onObservableError(r);
                 // TODO why aren't we throwing the hook's return value.
-                throw r;
+                throw r; // NOPMD 
             }
             return Subscriptions.unsubscribed();
         }
@@ -9112,7 +9112,7 @@ static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T
                     // TODO could the hook be the cause of the error in the on error handling.
                     RxJavaHooks.onObservableError(r);
                     // TODO why aren't we throwing the hook's return value.
-                    throw r;
+                    throw r; // NOPMD 
                 }
             }
             return Subscriptions.unsubscribed();
@@ -9306,12 +9306,13 @@ public final Observable<T> takeFirst(Func1<? super T, Boolean> predicate) {
      * @see <a href="http://reactivex.io/documentation/operators/takelast.html">ReactiveX operators documentation: TakeLast</a>
      */
     public final Observable<T> takeLast(final int count) {
-        if (count == 0)
+        if (count == 0) {
             return ignoreElements();
-        else if (count == 1 )
+        } else if (count == 1) {
             return lift(OperatorTakeLastOne.<T>instance());
-        else 
+        } else {
             return lift(new OperatorTakeLast<T>(count));
+        }
     }
 
     /**
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 183f869fd0..c4c4e71881 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -619,7 +619,7 @@ public static <T> Single<T> fromCallable(final Callable<? extends T> func) {
         return create(new OnSubscribe<T>() {
             @Override
             public void call(SingleSubscriber<? super T> singleSubscriber) {
-                final T value;
+                T value;
 
                 try {
                     value = func.call();
@@ -1719,7 +1719,7 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
                 // TODO could the hook be the cause of the error in the on error handling.
                 RxJavaHooks.onSingleError(r);
                 // TODO why aren't we throwing the hook's return value.
-                throw r;
+                throw r; // NOPMD 
             }
             return Subscriptions.unsubscribed();
         }
@@ -1829,7 +1829,7 @@ public final Subscription subscribe(Subscriber<? super T> subscriber) {
                 // TODO could the hook be the cause of the error in the on error handling.
                 RxJavaHooks.onSingleError(r);
                 // TODO why aren't we throwing the hook's return value.
-                throw r;
+                throw r; // NOPMD 
             }
             return Subscriptions.empty();
         }
@@ -1875,7 +1875,7 @@ public final Subscription subscribe(final SingleSubscriber<? super T> te) {
 
             @Override
             public void onCompleted() {
-
+                // deliberately ignored
             }
 
             @Override
@@ -2376,6 +2376,7 @@ public final Single<T> doOnError(final Action1<Throwable> onError) {
         Observer<T> observer = new Observer<T>() {
             @Override
             public void onCompleted() {
+                // deliberately ignored
             }
 
             @Override
@@ -2385,6 +2386,7 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(T t) {
+                // deliberately ignored
             }
         };
 
@@ -2410,10 +2412,12 @@ public final Single<T> doOnSuccess(final Action1<? super T> onSuccess) {
         Observer<T> observer = new Observer<T>() {
             @Override
             public void onCompleted() {
+                // deliberately ignored
             }
 
             @Override
             public void onError(Throwable e) {
+                // deliberately ignored
             }
 
             @Override
@@ -2589,7 +2593,7 @@ public final Single<T> doAfterTerminate(Action0 action) {
      */
     @SuppressWarnings("unchecked")
     static <T> Single<? extends T>[] iterableToArray(final Iterable<? extends Single<? extends T>> singlesIterable) {
-        final Single<? extends T>[] singlesArray;
+        Single<? extends T>[] singlesArray;
         int count;
 
         if (singlesIterable instanceof Collection) {
diff --git a/src/main/java/rx/exceptions/AssemblyStackTraceException.java b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
index ee6a8be6a9..752e8aad87 100644
--- a/src/main/java/rx/exceptions/AssemblyStackTraceException.java
+++ b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
@@ -46,7 +46,7 @@ public AssemblyStackTraceException(String message) {
     }
 
     @Override
-    public synchronized Throwable fillInStackTrace() {
+    public synchronized Throwable fillInStackTrace() { // NOPMD 
         return this;
     }
 }
diff --git a/src/main/java/rx/exceptions/CompositeException.java b/src/main/java/rx/exceptions/CompositeException.java
index 310cfab8ae..d4af4c5350 100644
--- a/src/main/java/rx/exceptions/CompositeException.java
+++ b/src/main/java/rx/exceptions/CompositeException.java
@@ -41,15 +41,17 @@ public final class CompositeException extends RuntimeException {
     private final List<Throwable> exceptions;
     private final String message;
 
+    private Throwable cause;
+
     /** 
      * Constructs a CompositeException with the given prefix and error collection.
      * @param messagePrefix the prefix to use (actually unused)
      * @param errors the collection of errors
      * @deprecated please use {@link #CompositeException(Collection)} */
     @Deprecated
-    public CompositeException(String messagePrefix, Collection<? extends Throwable> errors) {
+    public CompositeException(String messagePrefix, Collection<? extends Throwable> errors) { // NOPMD 
         Set<Throwable> deDupedExceptions = new LinkedHashSet<Throwable>();
-        List<Throwable> _exceptions = new ArrayList<Throwable>();
+        List<Throwable> localExceptions = new ArrayList<Throwable>();
         if (errors != null) {
             for (Throwable ex : errors) {
                 if (ex instanceof CompositeException) {
@@ -65,8 +67,8 @@ public CompositeException(String messagePrefix, Collection<? extends Throwable>
             deDupedExceptions.add(new NullPointerException());
         }
 
-        _exceptions.addAll(deDupedExceptions);
-        this.exceptions = Collections.unmodifiableList(_exceptions);
+        localExceptions.addAll(deDupedExceptions);
+        this.exceptions = Collections.unmodifiableList(localExceptions);
         this.message = exceptions.size() + " exceptions occurred. ";
     }
 
@@ -81,7 +83,7 @@ public CompositeException(Collection<? extends Throwable> errors) {
     @Experimental
     public CompositeException(Throwable... errors) {
         Set<Throwable> deDupedExceptions = new LinkedHashSet<Throwable>();
-        List<Throwable> _exceptions = new ArrayList<Throwable>();
+        List<Throwable> localExceptions = new ArrayList<Throwable>();
         if (errors != null) {
             for (Throwable ex : errors) {
                 if (ex instanceof CompositeException) {
@@ -97,8 +99,8 @@ public CompositeException(Throwable... errors) {
             deDupedExceptions.add(new NullPointerException());
         }
 
-        _exceptions.addAll(deDupedExceptions);
-        this.exceptions = Collections.unmodifiableList(_exceptions);
+        localExceptions.addAll(deDupedExceptions);
+        this.exceptions = Collections.unmodifiableList(localExceptions);
         this.message = exceptions.size() + " exceptions occurred. ";
     }
 
@@ -116,16 +118,14 @@ public String getMessage() {
         return message;
     }
 
-    private Throwable cause = null;
-
     @Override
-    public synchronized Throwable getCause() {
+    public synchronized Throwable getCause() { // NOPMD 
         if (cause == null) {
             // we lazily generate this causal chain if this is called
-            CompositeExceptionCausalChain _cause = new CompositeExceptionCausalChain();
+            CompositeExceptionCausalChain localCause = new CompositeExceptionCausalChain();
             Set<Throwable> seenCauses = new HashSet<Throwable>();
 
-            Throwable chain = _cause;
+            Throwable chain = localCause;
             for (Throwable e : exceptions) {
                 if (seenCauses.contains(e)) {
                     // already seen this outer Throwable so skip
@@ -147,14 +147,14 @@ public synchronized Throwable getCause() {
                 // we now have 'e' as the last in the chain
                 try {
                     chain.initCause(e);
-                } catch (Throwable t) {
+                } catch (Throwable t) { // NOPMD 
                     // ignore
                     // the javadocs say that some Throwables (depending on how they're made) will never
                     // let me call initCause without blowing up even if it returns null
                 }
                 chain = getRootCause(chain);
             }
-            cause = _cause;
+            cause = localCause;
         }
         return cause;
     }
@@ -192,14 +192,14 @@ public void printStackTrace(PrintWriter s) {
      *            stream to print to
      */
     private void printStackTrace(PrintStreamOrWriter s) {
-        StringBuilder bldr = new StringBuilder();
-        bldr.append(this).append("\n");
+        StringBuilder bldr = new StringBuilder(128);
+        bldr.append(this).append('\n');
         for (StackTraceElement myStackElement : getStackTrace()) {
-            bldr.append("\tat ").append(myStackElement).append("\n");
+            bldr.append("\tat ").append(myStackElement).append('\n');
         }
         int i = 1;
         for (Throwable ex : exceptions) {
-            bldr.append("  ComposedException ").append(i).append(" :").append("\n");
+            bldr.append("  ComposedException ").append(i).append(" :\n");
             appendStackTrace(bldr, ex, "\t");
             i++;
         }
@@ -209,9 +209,9 @@ private void printStackTrace(PrintStreamOrWriter s) {
     }
 
     private void appendStackTrace(StringBuilder bldr, Throwable ex, String prefix) {
-        bldr.append(prefix).append(ex).append("\n");
+        bldr.append(prefix).append(ex).append('\n');
         for (StackTraceElement stackElement : ex.getStackTrace()) {
-            bldr.append("\t\tat ").append(stackElement).append("\n");
+            bldr.append("\t\tat ").append(stackElement).append('\n');
         }
         if (ex.getCause() != null) {
             bldr.append("\tCaused by: ");
@@ -219,7 +219,7 @@ private void appendStackTrace(StringBuilder bldr, Throwable ex, String prefix) {
         }
     }
 
-    private abstract static class PrintStreamOrWriter {
+    abstract static class PrintStreamOrWriter {
         /** Returns the object to be locked when using this StreamOrWriter */
         abstract Object lock();
 
@@ -230,7 +230,7 @@ private abstract static class PrintStreamOrWriter {
     /**
      * Same abstraction and implementation as in JDK to allow PrintStream and PrintWriter to share implementation
      */
-    private static class WrappedPrintStream extends PrintStreamOrWriter {
+    static final class WrappedPrintStream extends PrintStreamOrWriter {
         private final PrintStream printStream;
 
         WrappedPrintStream(PrintStream printStream) {
@@ -248,7 +248,7 @@ void println(Object o) {
         }
     }
 
-    private static class WrappedPrintWriter extends PrintStreamOrWriter {
+    static final class WrappedPrintWriter extends PrintStreamOrWriter {
         private final PrintWriter printWriter;
 
         WrappedPrintWriter(PrintWriter printWriter) {
@@ -268,7 +268,7 @@ void println(Object o) {
 
     /* package-private */final static class CompositeExceptionCausalChain extends RuntimeException {
         private static final long serialVersionUID = 3875212506787802066L;
-        /* package-private */static String MESSAGE = "Chain of Causes for CompositeException In Order Received =>";
+        /* package-private */static final String MESSAGE = "Chain of Causes for CompositeException In Order Received =>";
 
         @Override
         public String getMessage() {
diff --git a/src/main/java/rx/exceptions/Exceptions.java b/src/main/java/rx/exceptions/Exceptions.java
index f427018f53..1486012d2d 100644
--- a/src/main/java/rx/exceptions/Exceptions.java
+++ b/src/main/java/rx/exceptions/Exceptions.java
@@ -26,6 +26,9 @@
  * manage fatal and regular exception delivery.
  */
 public final class Exceptions {
+
+    private static final int MAX_DEPTH = 25;
+
     /** Utility class, no instances. */
     private Exceptions() {
         throw new IllegalStateException("No instances!");
@@ -52,7 +55,7 @@ public static RuntimeException propagate(Throwable t) {
         } else if (t instanceof Error) {
             throw (Error) t;
         } else {
-            throw new RuntimeException(t);
+            throw new RuntimeException(t); // NOPMD 
         }
     }
     /**
@@ -96,8 +99,6 @@ else if (t instanceof StackOverflowError) {
         }
     }
 
-    private static final int MAX_DEPTH = 25;
-
     /**
      * Adds a {@code Throwable} to a causality-chain of Throwables, as an additional cause (if it does not
      * already appear in the chain among the causes).
@@ -126,7 +127,7 @@ public static void addCause(Throwable e, Throwable cause) {
         // we now have 'e' as the last in the chain
         try {
             e.initCause(cause);
-        } catch (Throwable t) {
+        } catch (Throwable t) { // NOPMD 
             // ignore
             // the javadocs say that some Throwables (depending on how they're made) will never
             // let me call initCause without blowing up even if it returns null
@@ -171,7 +172,7 @@ public static void throwIfAny(List<? extends Throwable> exceptions) {
                 } else if (t instanceof Error) {
                     throw (Error) t;
                 } else {
-                    throw new RuntimeException(t);
+                    throw new RuntimeException(t); // NOPMD 
                 }
             }
             throw new CompositeException(exceptions);
diff --git a/src/main/java/rx/exceptions/MissingBackpressureException.java b/src/main/java/rx/exceptions/MissingBackpressureException.java
index b113d6536c..3c11bc42d4 100644
--- a/src/main/java/rx/exceptions/MissingBackpressureException.java
+++ b/src/main/java/rx/exceptions/MissingBackpressureException.java
@@ -52,7 +52,7 @@ public class MissingBackpressureException extends Exception {
      * Constructs the exception without any custom message.
      */
     public MissingBackpressureException() {
-        
+        super();
     }
 
     /**
diff --git a/src/main/java/rx/exceptions/OnErrorThrowable.java b/src/main/java/rx/exceptions/OnErrorThrowable.java
index 2ef465141b..5f4ab73e8a 100644
--- a/src/main/java/rx/exceptions/OnErrorThrowable.java
+++ b/src/main/java/rx/exceptions/OnErrorThrowable.java
@@ -99,7 +99,7 @@ public static Throwable addValueAsLastCause(Throwable e, Object value) {
             e = new NullPointerException();
         }
         Throwable lastCause = Exceptions.getFinalCause(e);
-        if (lastCause != null && lastCause instanceof OnNextValue) {
+        if (lastCause instanceof OnNextValue) {
             // purposefully using == for object reference check
             if (((OnNextValue) lastCause).getValue() == value) {
                 // don't add another
@@ -117,9 +117,11 @@ public static Throwable addValueAsLastCause(Throwable e, Object value) {
     public static class OnNextValue extends RuntimeException {
 
         private static final long serialVersionUID = -3454462756050397899L;
+
+        private final Object value;
         
         // Lazy loaded singleton 
-        private static final class Primitives {
+        static final class Primitives {
             
             static final Set<Class<?>> INSTANCE = create();
 
@@ -139,8 +141,6 @@ private static Set<Class<?>> create() {
             }
         }
 
-        private final Object value;
-
         /**
          * Create an {@code OnNextValue} exception and include in its error message a string representation of
          * the item that was intended to be emitted at the time the exception was handled.
diff --git a/src/main/java/rx/functions/Actions.java b/src/main/java/rx/functions/Actions.java
index 877c1adbda..d204d16ebc 100644
--- a/src/main/java/rx/functions/Actions.java
+++ b/src/main/java/rx/functions/Actions.java
@@ -19,6 +19,9 @@
  * Utility class for the Action interfaces.
  */
 public final class Actions {
+    @SuppressWarnings("rawtypes")
+    private static final EmptyAction EMPTY_ACTION = new EmptyAction();
+
     private Actions() {
         throw new IllegalStateException("No instances!");
     }
@@ -28,10 +31,7 @@ public static <T0, T1, T2, T3, T4, T5, T6, T7, T8> EmptyAction<T0, T1, T2, T3, T
         return EMPTY_ACTION;
     }
 
-    @SuppressWarnings("rawtypes")
-    private static final EmptyAction EMPTY_ACTION = new EmptyAction();
-
-    private static final class EmptyAction<T0, T1, T2, T3, T4, T5, T6, T7, T8> implements
+    static final class EmptyAction<T0, T1, T2, T3, T4, T5, T6, T7, T8> implements
             Action0,
             Action1<T0>,
             Action2<T0, T1>,
@@ -43,51 +43,60 @@ private static final class EmptyAction<T0, T1, T2, T3, T4, T5, T6, T7, T8> imple
             Action8<T0, T1, T2, T3, T4, T5, T6, T7>,
             Action9<T0, T1, T2, T3, T4, T5, T6, T7, T8>,
             ActionN {
-        EmptyAction() {
-        }
 
         @Override
         public void call() {
+            // deliberately no op
         }
 
         @Override
         public void call(T0 t1) {
+            // deliberately no op
         }
 
         @Override
         public void call(T0 t1, T1 t2) {
+            // deliberately no op
         }
 
         @Override
         public void call(T0 t1, T1 t2, T2 t3) {
+            // deliberately no op
         }
 
         @Override
         public void call(T0 t1, T1 t2, T2 t3, T3 t4) {
+            // deliberately no op
         }
 
         @Override
         public void call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5) {
+            // deliberately no op
         }
 
         @Override
         public void call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6) {
+            // deliberately no op
         }
 
         @Override
         public void call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7) {
+            // deliberately no op
         }
 
         @Override
         public void call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8) {
+            // deliberately no op
         }
 
         @Override
         public void call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8, T8 t9) {
+            // deliberately no op
         }
 
         @Override
         public void call(Object... args) {
+            // deliberately no op
         }
     }
     
diff --git a/src/main/java/rx/functions/Functions.java b/src/main/java/rx/functions/Functions.java
index b22df29204..24036ec498 100644
--- a/src/main/java/rx/functions/Functions.java
+++ b/src/main/java/rx/functions/Functions.java
@@ -34,7 +34,7 @@ public static <R> FuncN<R> fromFunc(final Func0<? extends R> f) {
             @Override
             public R call(Object... args) {
                 if (args.length != 0) {
-                    throw new RuntimeException("Func0 expecting 0 arguments.");
+                    throw new IllegalArgumentException("Func0 expecting 0 arguments.");
                 }
                 return f.call();
             }
@@ -58,7 +58,7 @@ public static <T0, R> FuncN<R> fromFunc(final Func1<? super T0, ? extends R> f)
             @Override
             public R call(Object... args) {
                 if (args.length != 1) {
-                    throw new RuntimeException("Func1 expecting 1 argument.");
+                    throw new IllegalArgumentException("Func1 expecting 1 argument.");
                 }
                 return f.call((T0) args[0]);
             }
@@ -83,7 +83,7 @@ public static <T0, T1, R> FuncN<R> fromFunc(final Func2<? super T0, ? super T1,
             @Override
             public R call(Object... args) {
                 if (args.length != 2) {
-                    throw new RuntimeException("Func2 expecting 2 arguments.");
+                    throw new IllegalArgumentException("Func2 expecting 2 arguments.");
                 }
                 return f.call((T0) args[0], (T1) args[1]);
             }
@@ -109,7 +109,7 @@ public static <T0, T1, T2, R> FuncN<R> fromFunc(final Func3<? super T0, ? super
             @Override
             public R call(Object... args) {
                 if (args.length != 3) {
-                    throw new RuntimeException("Func3 expecting 3 arguments.");
+                    throw new IllegalArgumentException("Func3 expecting 3 arguments.");
                 }
                 return f.call((T0) args[0], (T1) args[1], (T2) args[2]);
             }
@@ -136,7 +136,7 @@ public static <T0, T1, T2, T3, R> FuncN<R> fromFunc(final Func4<? super T0, ? su
             @Override
             public R call(Object... args) {
                 if (args.length != 4) {
-                    throw new RuntimeException("Func4 expecting 4 arguments.");
+                    throw new IllegalArgumentException("Func4 expecting 4 arguments.");
                 }
                 return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3]);
             }
@@ -164,7 +164,7 @@ public static <T0, T1, T2, T3, T4, R> FuncN<R> fromFunc(final Func5<? super T0,
             @Override
             public R call(Object... args) {
                 if (args.length != 5) {
-                    throw new RuntimeException("Func5 expecting 5 arguments.");
+                    throw new IllegalArgumentException("Func5 expecting 5 arguments.");
                 }
                 return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3], (T4) args[4]);
             }
@@ -193,7 +193,7 @@ public static <T0, T1, T2, T3, T4, T5, R> FuncN<R> fromFunc(final Func6<? super
             @Override
             public R call(Object... args) {
                 if (args.length != 6) {
-                    throw new RuntimeException("Func6 expecting 6 arguments.");
+                    throw new IllegalArgumentException("Func6 expecting 6 arguments.");
                 }
                 return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3], (T4) args[4], (T5) args[5]);
             }
@@ -223,7 +223,7 @@ public static <T0, T1, T2, T3, T4, T5, T6, R> FuncN<R> fromFunc(final Func7<? su
             @Override
             public R call(Object... args) {
                 if (args.length != 7) {
-                    throw new RuntimeException("Func7 expecting 7 arguments.");
+                    throw new IllegalArgumentException("Func7 expecting 7 arguments.");
                 }
                 return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3], (T4) args[4], (T5) args[5], (T6) args[6]);
             }
@@ -254,7 +254,7 @@ public static <T0, T1, T2, T3, T4, T5, T6, T7, R> FuncN<R> fromFunc(final Func8<
             @Override
             public R call(Object... args) {
                 if (args.length != 8) {
-                    throw new RuntimeException("Func8 expecting 8 arguments.");
+                    throw new IllegalArgumentException("Func8 expecting 8 arguments.");
                 }
                 return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3], (T4) args[4], (T5) args[5], (T6) args[6], (T7) args[7]);
             }
@@ -286,7 +286,7 @@ public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, R> FuncN<R> fromFunc(final Fu
             @Override
             public R call(Object... args) {
                 if (args.length != 9) {
-                    throw new RuntimeException("Func9 expecting 9 arguments.");
+                    throw new IllegalArgumentException("Func9 expecting 9 arguments.");
                 }
                 return f.call((T0) args[0], (T1) args[1], (T2) args[2], (T3) args[3], (T4) args[4], (T5) args[5], (T6) args[6], (T7) args[7], (T8) args[8]);
             }
@@ -307,7 +307,7 @@ public static FuncN<Void> fromAction(final Action0 f) {
             @Override
             public Void call(Object... args) {
                 if (args.length != 0) {
-                    throw new RuntimeException("Action0 expecting 0 arguments.");
+                    throw new IllegalArgumentException("Action0 expecting 0 arguments.");
                 }
                 f.call();
                 return null;
@@ -331,7 +331,7 @@ public static <T0> FuncN<Void> fromAction(final Action1<? super T0> f) {
             @Override
             public Void call(Object... args) {
                 if (args.length != 1) {
-                    throw new RuntimeException("Action1 expecting 1 argument.");
+                    throw new IllegalArgumentException("Action1 expecting 1 argument.");
                 }
                 f.call((T0) args[0]);
                 return null;
@@ -356,7 +356,7 @@ public static <T0, T1> FuncN<Void> fromAction(final Action2<? super T0, ? super
             @Override
             public Void call(Object... args) {
                 if (args.length != 2) {
-                    throw new RuntimeException("Action3 expecting 2 arguments.");
+                    throw new IllegalArgumentException("Action3 expecting 2 arguments.");
                 }
                 f.call((T0) args[0], (T1) args[1]);
                 return null;
@@ -382,7 +382,7 @@ public static <T0, T1, T2> FuncN<Void> fromAction(final Action3<? super T0, ? su
             @Override
             public Void call(Object... args) {
                 if (args.length != 3) {
-                    throw new RuntimeException("Action3 expecting 3 arguments.");
+                    throw new IllegalArgumentException("Action3 expecting 3 arguments.");
                 }
                 f.call((T0) args[0], (T1) args[1], (T2) args[2]);
                 return null;
diff --git a/src/main/java/rx/internal/operators/BackpressureUtils.java b/src/main/java/rx/internal/operators/BackpressureUtils.java
index 6a13709649..5d63ab7c27 100644
--- a/src/main/java/rx/internal/operators/BackpressureUtils.java
+++ b/src/main/java/rx/internal/operators/BackpressureUtils.java
@@ -27,6 +27,15 @@
  *
  */
 public final class BackpressureUtils {
+    /**
+     * Masks the most significant bit, i.e., 0x8000_0000_0000_0000L.
+     */
+    static final long COMPLETED_MASK = Long.MIN_VALUE;
+    /**
+     * Masks the request amount bits, i.e., 0x7FFF_FFFF_FFFF_FFFF.
+     */
+    static final long REQUESTED_MASK = Long.MAX_VALUE;
+
     /** Utility class, no instances. */
     private BackpressureUtils() {
         throw new IllegalStateException("No instances!");
@@ -111,15 +120,6 @@ public static long addCap(long a, long b) {
         return u;
     }
     
-    /**
-     * Masks the most significant bit, i.e., 0x8000_0000_0000_0000L.
-     */
-    static final long COMPLETED_MASK = Long.MIN_VALUE;
-    /**
-     * Masks the request amount bits, i.e., 0x7FFF_FFFF_FFFF_FFFF.
-     */
-    static final long REQUESTED_MASK = Long.MAX_VALUE;
-    
     /**
      * Signals the completion of the main sequence and switches to post-completion replay mode.
      * 
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
index 2a75eceb43..a07588007b 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
@@ -62,6 +62,8 @@ static final class LatestObserverIterator<T> extends Subscriber<Notification<? e
         final Semaphore notify = new Semaphore(0);
         // observer's notification
         final AtomicReference<Notification<? extends T>> value = new AtomicReference<Notification<? extends T>>();
+        // iterator's notification
+        Notification<? extends T> iNotif;
 
         @Override
         public void onNext(Notification<? extends T> args) {
@@ -81,9 +83,6 @@ public void onCompleted() {
             // not expected
         }
 
-        // iterator's notification
-        Notification<? extends T> iNotif;
-
         @Override
         public boolean hasNext() {
             if (iNotif != null && iNotif.isOnError()) {
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java b/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
index 3a55cf0cb7..507f1ee708 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
@@ -62,7 +62,7 @@ public Iterator<T> iterator() {
         };
     }
 
-    private static final class MostRecentObserver<T> extends Subscriber<T> {
+    static final class MostRecentObserver<T> extends Subscriber<T> {
         final NotificationLite<T> nl = NotificationLite.instance();
         volatile Object value;
 
@@ -95,7 +95,7 @@ public Iterator<T> getIterable() {
                 /**
                  * buffer to make sure that the state of the iterator doesn't change between calling hasNext() and next().
                  */
-                private Object buf = null;
+                private Object buf;
 
                 @Override
                 public boolean hasNext() {
@@ -107,10 +107,12 @@ public boolean hasNext() {
                 public T next() {
                     try {
                         // if hasNext wasn't called before calling next.
-                        if (buf == null)
+                        if (buf == null) {
                             buf = value;
-                        if (nl.isCompleted(buf))
+                        }
+                        if (nl.isCompleted(buf)) {
                             throw new NoSuchElementException();
+                        }
                         if (nl.isError(buf)) {
                             throw Exceptions.propagate(nl.getError(buf));
                         }
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorNext.java b/src/main/java/rx/internal/operators/BlockingOperatorNext.java
index 94820b4acf..236744ac31 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorNext.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorNext.java
@@ -64,8 +64,8 @@ public Iterator<T> iterator() {
         private T next;
         private boolean hasNext = true;
         private boolean isNextConsumed = true;
-        private Throwable error = null;
-        private boolean started = false;
+        private Throwable error;
+        private boolean started;
 
         NextIterator(Observable<? extends T> items, NextObserver<T> observer) {
             this.items = items;
@@ -122,7 +122,7 @@ private boolean moveToNext() {
                 observer.unsubscribe();
                 Thread.currentThread().interrupt();
                 error = e;
-                throw Exceptions.propagate(error);
+                throw Exceptions.propagate(e);
             }
         }
 
@@ -147,13 +147,10 @@ public void remove() {
         }
     }
 
-    private static class NextObserver<T> extends Subscriber<Notification<? extends T>> {
+    static final class NextObserver<T> extends Subscriber<Notification<? extends T>> {
         private final BlockingQueue<Notification<? extends T>> buf = new ArrayBlockingQueue<Notification<? extends T>>(1);
         final AtomicInteger waiting = new AtomicInteger();
 
-        NextObserver() {
-        }
-
         @Override
         public void onCompleted() {
             // ignore
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java b/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
index 20a2377472..ee43643fce 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
@@ -77,7 +77,7 @@ public void onNext(T v) {
 
         return new Future<T>() {
 
-            private volatile boolean cancelled = false;
+            private volatile boolean cancelled;
 
             @Override
             public boolean cancel(boolean mayInterruptIfRunning) {
diff --git a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
index 2fcf60cf45..f97198ee28 100644
--- a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
+++ b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
@@ -48,6 +48,9 @@
  *            the type of the items to be buffered
  */
 public final class BufferUntilSubscriber<T> extends Subject<T, T> {
+    final State<T> state;
+
+    private boolean forward;
 
     /**
      * Creates a default, unbounded buffering Subject instance.
@@ -63,16 +66,17 @@ public static <T> BufferUntilSubscriber<T> create() {
     static final class State<T> extends AtomicReference<Observer<? super T>> {
         /** */
         private static final long serialVersionUID = 8026705089538090368L;
-        boolean casObserverRef(Observer<? super T>  expected, Observer<? super T>  next) {
-            return compareAndSet(expected, next);
-        }
 
         final Object guard = new Object();
         /* protected by guard */
-        boolean emitting = false;
+        boolean emitting;
 
         final ConcurrentLinkedQueue<Object> buffer = new ConcurrentLinkedQueue<Object>();
         final NotificationLite<T> nl = NotificationLite.instance();
+
+        boolean casObserverRef(Observer<? super T>  expected, Observer<? super T>  next) {
+            return compareAndSet(expected, next);
+        }
     }
     
     static final class OnSubscribeAction<T> implements OnSubscribe<T> {
@@ -123,9 +127,6 @@ public void call() {
         }
         
     }
-    final State<T> state;
-
-    private boolean forward = false;
 
     private BufferUntilSubscriber(State<T> state) {
         super(new OnSubscribeAction<T>(state));
@@ -194,17 +195,17 @@ public boolean hasObservers() {
 
         @Override
         public void onCompleted() {
-            
+            // deliberately no op
         }
 
         @Override
         public void onError(Throwable e) {
-            
+            // deliberately no op
         }
 
         @Override
         public void onNext(Object t) {
-            
+            // deliberately no op
         }
         
     };
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
index 9d2567135e..55583c85ad 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
@@ -34,9 +34,6 @@ public CompletableOnSubscribeMergeDelayErrorIterable(Iterable<? extends Completa
     @Override
     public void call(final CompletableSubscriber s) {
         final CompositeSubscription set = new CompositeSubscription();
-        final AtomicInteger wip = new AtomicInteger(1);
-        
-        final Queue<Throwable> queue = new MpscLinkedQueue<Throwable>();
         
         s.onSubscribe(set);
         
@@ -53,7 +50,11 @@ public void call(final CompletableSubscriber s) {
             s.onError(new NullPointerException("The source iterator returned is null"));
             return;
         }
+
+        final AtomicInteger wip = new AtomicInteger(1);
         
+        final Queue<Throwable> queue = new MpscLinkedQueue<Throwable>();
+
         for (;;) {
             if (set.isUnsubscribed()) {
                 return;
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
index fed111a6c7..9d09393bbe 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
@@ -34,9 +34,7 @@ public CompletableOnSubscribeMergeIterable(Iterable<? extends Completable> sourc
     @Override
     public void call(final CompletableSubscriber s) {
         final CompositeSubscription set = new CompositeSubscription();
-        final AtomicInteger wip = new AtomicInteger(1);
-        final AtomicBoolean once = new AtomicBoolean();
-        
+
         s.onSubscribe(set);
         
         Iterator<? extends Completable> iterator;
@@ -53,6 +51,9 @@ public void call(final CompletableSubscriber s) {
             return;
         }
         
+        final AtomicInteger wip = new AtomicInteger(1);
+        final AtomicBoolean once = new AtomicBoolean();
+
         for (;;) {
             if (set.isUnsubscribed()) {
                 return;
diff --git a/src/main/java/rx/internal/operators/EmptyObservableHolder.java b/src/main/java/rx/internal/operators/EmptyObservableHolder.java
index 00f4e16f68..c9678db92d 100644
--- a/src/main/java/rx/internal/operators/EmptyObservableHolder.java
+++ b/src/main/java/rx/internal/operators/EmptyObservableHolder.java
@@ -26,7 +26,11 @@
 public enum EmptyObservableHolder implements OnSubscribe<Object> {
     INSTANCE
     ;
+
+    /** The singleton instance. */
+    static final Observable<Object> EMPTY = Observable.create(INSTANCE);
     
+
     /**
      * Returns a type-corrected singleton instance of the empty Observable.
      * @param <T> the value type
@@ -37,9 +41,6 @@ public static <T> Observable<T> instance() {
         return (Observable<T>)EMPTY;
     }
     
-    /** The singleton instance. */
-    static final Observable<Object> EMPTY = Observable.create(INSTANCE);
-    
     @Override
     public void call(Subscriber<? super Object> child) {
         child.onCompleted();
diff --git a/src/main/java/rx/internal/operators/NeverObservableHolder.java b/src/main/java/rx/internal/operators/NeverObservableHolder.java
index 5114772872..4ffdc630d8 100644
--- a/src/main/java/rx/internal/operators/NeverObservableHolder.java
+++ b/src/main/java/rx/internal/operators/NeverObservableHolder.java
@@ -26,7 +26,10 @@
 public enum NeverObservableHolder implements OnSubscribe<Object> {
     INSTANCE
     ;
-    
+
+    /** The singleton instance. */
+    static final Observable<Object> NEVER = Observable.create(INSTANCE);
+
     /**
      * Returns a type-corrected singleton instance of the never Observable.
      * @param <T> the value type
@@ -37,10 +40,8 @@ public static <T> Observable<T> instance() {
         return (Observable<T>)NEVER;
     }
     
-    /** The singleton instance. */
-    static final Observable<Object> NEVER = Observable.create(INSTANCE);
-    
     @Override
     public void call(Subscriber<? super Object> child) {
+        // deliberately no op
     }
 }
diff --git a/src/main/java/rx/internal/operators/NotificationLite.java b/src/main/java/rx/internal/operators/NotificationLite.java
index 223d5299cd..7047553dc9 100644
--- a/src/main/java/rx/internal/operators/NotificationLite.java
+++ b/src/main/java/rx/internal/operators/NotificationLite.java
@@ -31,16 +31,16 @@
  * <p>
  * It's implemented as a singleton to maintain some semblance of type safety that is completely non-existent.
  * 
- * @param <T>
- * @warn type param undescribed
+ * @param <T> the element type
  */
 public final class NotificationLite<T> {
-    private NotificationLite() {
-    }
-
     @SuppressWarnings("rawtypes")
     private static final NotificationLite INSTANCE = new NotificationLite();
 
+    private NotificationLite() {
+        // singleton
+    }
+
     /**
      * Gets the {@code NotificationLite} singleton.
      *
@@ -70,7 +70,7 @@ public String toString() {
         }
     };
 
-    private static class OnErrorSentinel implements Serializable {
+    static final class OnErrorSentinel implements Serializable {
         private static final long serialVersionUID = 3;
         final Throwable e;
 
@@ -93,10 +93,11 @@ public String toString() {
      * @return the item, or a null token representing the item if the item is {@code null}
      */
     public Object next(T t) {
-        if (t == null)
+        if (t == null) {
             return ON_NEXT_NULL_SENTINEL;
-        else
+        } else {
             return t;
+        }
     }
 
     /**
@@ -207,15 +208,16 @@ public boolean isNext(Object n) {
      *         {@code Kind.OnError}, or {@code Kind.OnNext}
      */
     public Kind kind(Object n) {
-        if (n == null)
+        if (n == null) {
             throw new IllegalArgumentException("The lite notification can not be null");
-        else if (n == ON_COMPLETED_SENTINEL)
+        } else if (n == ON_COMPLETED_SENTINEL) {
             return Kind.OnCompleted;
-        else if (n instanceof OnErrorSentinel)
+        } else if (n instanceof OnErrorSentinel) {
             return Kind.OnError;
-        else
+        } else {
             // value or ON_NEXT_NULL_SENTINEL but either way it's an OnNext
             return Kind.OnNext;
+        }
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeAmb.java b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
index 3b39357b07..f10e73396c 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeAmb.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
@@ -33,6 +33,9 @@
  * @param <T> the value type
  */
 public final class OnSubscribeAmb<T> implements OnSubscribe<T>{
+    //give default access instead of private as a micro-optimization 
+    //for access from anonymous classes below
+    final Iterable<? extends Observable<? extends T>> sources;
 
     /**
      * Given two {@link Observable}s, propagates the one that first emits an item.
@@ -275,7 +278,7 @@ public static <T> OnSubscribe<T> amb(final Iterable<? extends Observable<? exten
         return new OnSubscribeAmb<T>(sources);
     }
 
-    private static final class AmbSubscriber<T> extends Subscriber<T> {
+    static final class AmbSubscriber<T> extends Subscriber<T> {
 
         private final Subscriber<? super T> subscriber;
         private final Selection<T> selection;
@@ -338,7 +341,7 @@ private boolean isSelected() {
         }
     }
 
-    private static class Selection<T> {
+    static final class Selection<T> {
         final AtomicReference<AmbSubscriber<T>> choice = new AtomicReference<AmbSubscriber<T>>();
         final Collection<AmbSubscriber<T>> ambSubscribers = new ConcurrentLinkedQueue<AmbSubscriber<T>>();
 
@@ -360,10 +363,6 @@ public void unsubscribeOthers(AmbSubscriber<T> notThis) {
 
     }
     
-    //give default access instead of private as a micro-optimization 
-    //for access from anonymous classes below
-    final Iterable<? extends Observable<? extends T>> sources;
-    
     private OnSubscribeAmb(Iterable<? extends Observable<? extends T>> sources) {
         this.sources = sources;
     }
@@ -419,7 +418,7 @@ public void call() {
 
             @Override
             public void request(long n) {
-                final AmbSubscriber<T> c;
+                AmbSubscriber<T> c;
                 if ((c = choice.get()) != null) {
                     // propagate the request to that single Subscriber that won
                     c.requestMore(n);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
index e9dac2d026..e7cb3a1251 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
@@ -245,10 +245,9 @@ void drain() {
                 }
                 
                 long requestAmount = localRequested.get();
-                boolean unbounded = requestAmount == Long.MAX_VALUE;
                 long emitted = 0L;
                 
-                while (requestAmount != 0L) {
+                while (emitted != requestAmount) {
                     
                     boolean d = done;
                     @SuppressWarnings("unchecked")
@@ -287,14 +286,11 @@ void drain() {
                     
                     cs.requestMore(1);
                     
-                    requestAmount--;
-                    emitted--;
+                    emitted++;
                 }
                 
-                if (emitted != 0L) {
-                    if (!unbounded) {
-                        localRequested.addAndGet(emitted);
-                    }
+                if (emitted != 0L && requestAmount != Long.MAX_VALUE) {
+                    BackpressureUtils.produced(localRequested, emitted);
                 }
                 
                 missed = addAndGet(-missed);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java b/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
index 9ee3104f95..889cce2872 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
@@ -44,7 +44,7 @@ public OnSubscribeFromIterable(Iterable<? extends T> iterable) {
 
     @Override
     public void call(final Subscriber<? super T> o) {
-        final Iterator<? extends T> it;
+        Iterator<? extends T> it;
         boolean b;
         
         try {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java b/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
index a8f13fb5e7..e677fb9bc3 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
@@ -38,11 +38,11 @@
  * @param <R> the result value type
  */
 public final class OnSubscribeGroupJoin<T1, T2, D1, D2, R> implements OnSubscribe<R> {
-    protected final Observable<T1> left;
-    protected final Observable<T2> right;
-    protected final Func1<? super T1, ? extends Observable<D1>> leftDuration;
-    protected final Func1<? super T2, ? extends Observable<D2>> rightDuration;
-    protected final Func2<? super T1, ? super Observable<T2>, ? extends R> resultSelector;
+    final Observable<T1> left;
+    final Observable<T2> right;
+    final Func1<? super T1, ? extends Observable<D1>> leftDuration;
+    final Func1<? super T2, ? extends Observable<D2>> rightDuration;
+    final Func2<? super T1, ? super Observable<T2>, ? extends R> resultSelector;
 
     public OnSubscribeGroupJoin(
             Observable<T1> left,
@@ -75,9 +75,9 @@ final class ResultManager implements Subscription {
         /** Guarded by guard. */
         int rightIds;
         /** Guarded by guard. */
-        final Map<Integer, Observer<T2>> leftMap = new HashMap<Integer, Observer<T2>>();
+        final Map<Integer, Observer<T2>> leftMap = new HashMap<Integer, Observer<T2>>(); // NOPMD 
         /** Guarded by guard. */
-        final Map<Integer, T2> rightMap = new HashMap<Integer, T2>();
+        final Map<Integer, T2> rightMap = new HashMap<Integer, T2>(); // NOPMD 
         /** Guarded by guard. */
         boolean leftDone;
         /** Guarded by guard. */
diff --git a/src/main/java/rx/internal/operators/OnSubscribeRange.java b/src/main/java/rx/internal/operators/OnSubscribeRange.java
index 8f17303a2d..1a96c152c8 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRange.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRange.java
@@ -38,7 +38,7 @@ public void call(final Subscriber<? super Integer> childSubscriber) {
         childSubscriber.setProducer(new RangeProducer(childSubscriber, startIndex, endIndex));
     }
 
-    private static final class RangeProducer extends AtomicLong implements Producer {
+    static final class RangeProducer extends AtomicLong implements Producer {
         /** */
         private static final long serialVersionUID = 4114392207069098388L;
         
diff --git a/src/main/java/rx/internal/operators/OnSubscribeRedo.java b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
index d30ddc1343..c41b211558 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRedo.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
@@ -53,6 +53,11 @@
 import rx.subscriptions.SerialSubscription;
 
 public final class OnSubscribeRedo<T> implements OnSubscribe<T> {
+    final Observable<T> source;
+    private final Func1<? super Observable<? extends Notification<?>>, ? extends Observable<?>> controlHandlerFunction;
+    final boolean stopOnComplete;
+    final boolean stopOnError;
+    private final Scheduler scheduler;
 
     static final Func1<Observable<? extends Notification<?>>, Observable<?>> REDO_INFINITE = new Func1<Observable<? extends Notification<?>>, Observable<?>>() {
         @Override
@@ -77,7 +82,7 @@ public RedoFinite(long count) {
         public Observable<?> call(Observable<? extends Notification<?>> ts) {
             return ts.map(new Func1<Notification<?>, Notification<?>>() {
 
-                int num=0;
+                int num;
                 
                 @Override
                 public Notification<?> call(Notification<?> terminalNotification) {
@@ -111,10 +116,11 @@ public Observable<? extends Notification<?>> call(Observable<? extends Notificat
                 @Override
                 public Notification<Integer> call(Notification<Integer> n, Notification<?> term) {
                     final int value = n.getValue();
-                    if (predicate.call(value, term.getThrowable()))
+                    if (predicate.call(value, term.getThrowable())) {
                         return Notification.createOnNext(value + 1);
-                    else
+                    } else {
                         return (Notification<Integer>) term;
+                    }
                 }
             });
         }
@@ -125,10 +131,12 @@ public static <T> Observable<T> retry(Observable<T> source) {
     }
 
     public static <T> Observable<T> retry(Observable<T> source, final long count) {
-        if (count < 0)
+        if (count < 0) {
             throw new IllegalArgumentException("count >= 0 expected");
-        if (count == 0)
+        }
+        if (count == 0) {
             return source;
+        }
         return retry(source, new RedoFinite(count));
     }
 
@@ -156,8 +164,9 @@ public static <T> Observable<T> repeat(Observable<T> source, final long count, S
         if(count == 0) {
             return Observable.empty();
         }
-        if (count < 0)
+        if (count < 0) {
             throw new IllegalArgumentException("count >= 0 expected");
+        }
         return repeat(source, new RedoFinite(count - 1), scheduler);
     }
 
@@ -173,12 +182,6 @@ public static <T> Observable<T> redo(Observable<T> source, Func1<? super Observa
         return create(new OnSubscribeRedo<T>(source, notificationHandler, false, false, scheduler));
     }
 
-    final Observable<T> source;
-    private final Func1<? super Observable<? extends Notification<?>>, ? extends Observable<?>> controlHandlerFunction;
-    final boolean stopOnComplete;
-    final boolean stopOnError;
-    private final Scheduler scheduler;
-
     private OnSubscribeRedo(Observable<T> source, Func1<? super Observable<? extends Notification<?>>, ? extends Observable<?>> f, boolean stopOnComplete, boolean stopOnError,
             Scheduler scheduler) {
         this.source = source;
@@ -362,8 +365,9 @@ public void request(final long n) {
                 if (n > 0) {
                     BackpressureUtils.getAndAddRequest(consumerCapacity, n);
                     arbiter.request(n);
-                    if (resumeBoundary.compareAndSet(true, false))
+                    if (resumeBoundary.compareAndSet(true, false)) {
                         worker.schedule(subscribeToSource);
+                    }
                 }
             }
         });
diff --git a/src/main/java/rx/internal/operators/OnSubscribeSingle.java b/src/main/java/rx/internal/operators/OnSubscribeSingle.java
index 7bfdcca511..90dc8d288e 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeSingle.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeSingle.java
@@ -38,9 +38,9 @@ public OnSubscribeSingle(Observable<T> observable) {
     @Override
     public void call(final SingleSubscriber<? super T> child) {
         Subscriber<T> parent = new Subscriber<T>() {
-            private boolean emittedTooMany = false;
-            private boolean itemEmitted = false;
-            private T emission = null;
+            private boolean emittedTooMany;
+            private boolean itemEmitted;
+            private T emission;
 
             @Override
             public void onStart() {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeUsing.java b/src/main/java/rx/internal/operators/OnSubscribeUsing.java
index 352c699056..5b5a9259fb 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeUsing.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeUsing.java
@@ -58,7 +58,7 @@ public void call(final Subscriber<? super T> subscriber) {
             // dispose on unsubscription
             subscriber.add(disposeOnceOnly);
             // create the observable
-            final Observable<? extends T> source;
+            Observable<? extends T> source;
 
             try {
                 source = observableFactory
@@ -77,7 +77,7 @@ public void call(final Subscriber<? super T> subscriber) {
                 return;
             }
 
-            final Observable<? extends T> observable;
+            Observable<? extends T> observable;
             // supplement with on termination disposal if requested
             if (disposeEagerly) {
                 observable = source
@@ -96,11 +96,12 @@ public void call(final Subscriber<? super T> subscriber) {
                 Throwable disposeError = dispose(disposeOnceOnly);
                 Exceptions.throwIfFatal(e);
                 Exceptions.throwIfFatal(disposeError);
-                if (disposeError != null)
+                if (disposeError != null) {
                     subscriber.onError(new CompositeException(e, disposeError));
-                else
+                } else {
                     // propagate error
                     subscriber.onError(e);
+                }
             }
         } catch (Throwable e) {
             // then propagate error
@@ -117,7 +118,7 @@ private Throwable dispose(final Action0 disposeOnceOnly) {
         }
     }
 
-    private static final class DisposeAction<Resource> extends AtomicBoolean implements Action0,
+    static final class DisposeAction<Resource> extends AtomicBoolean implements Action0,
             Subscription {
         private static final long serialVersionUID = 4262875056400218316L;
 
diff --git a/src/main/java/rx/internal/operators/OperatorAsObservable.java b/src/main/java/rx/internal/operators/OperatorAsObservable.java
index 9cb9d8ac56..33671e8f2e 100644
--- a/src/main/java/rx/internal/operators/OperatorAsObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorAsObservable.java
@@ -26,7 +26,7 @@
  */
 public final class OperatorAsObservable<T> implements Operator<T, T> {
     /** Lazy initialization via inner-class holder. */
-    private static final class Holder {
+    static final class Holder {
         /** A singleton instance. */
         static final OperatorAsObservable<Object> INSTANCE = new OperatorAsObservable<Object>();
     }
@@ -38,7 +38,10 @@ private static final class Holder {
     public static <T> OperatorAsObservable<T> instance() {
         return (OperatorAsObservable<T>)Holder.INSTANCE;
     }
-    OperatorAsObservable() { }
+    OperatorAsObservable() { 
+        // singleton
+    }
+    
     @Override
     public Subscriber<? super T> call(Subscriber<? super T> s) {
         return s;
diff --git a/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java b/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
index f98639aff3..50c2418228 100644
--- a/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
@@ -110,7 +110,7 @@ static final class DebounceState<T> {
         /** Guarded by this. */
         boolean emitting;
         
-        public synchronized int next(T value) {
+        public synchronized int next(T value) { // NOPMD 
             this.value = value;
             this.hasValue = true;
             return ++index;
@@ -173,7 +173,7 @@ public void emitAndComplete(Subscriber<T> onNextAndComplete, Subscriber<?> onErr
             }
             onNextAndComplete.onCompleted();
         }
-        public synchronized void clear() {
+        public synchronized void clear() { // NOPMD 
             ++index;
             value = null;
             hasValue = false;
diff --git a/src/main/java/rx/internal/operators/OperatorDematerialize.java b/src/main/java/rx/internal/operators/OperatorDematerialize.java
index 5fd8d7fdfa..23eea9f1e8 100644
--- a/src/main/java/rx/internal/operators/OperatorDematerialize.java
+++ b/src/main/java/rx/internal/operators/OperatorDematerialize.java
@@ -31,7 +31,7 @@
  */
 public final class OperatorDematerialize<T> implements Operator<T, Notification<T>> {
     /** Lazy initialization via inner-class holder. */
-    private static final class Holder {
+    static final class Holder {
         /** A singleton instance. */
         static final OperatorDematerialize<Object> INSTANCE = new OperatorDematerialize<Object>();
     }
@@ -42,7 +42,10 @@ private static final class Holder {
     public static OperatorDematerialize instance() {
         return Holder.INSTANCE; // using raw types because the type inference is not good enough
     }
-    OperatorDematerialize() { }
+    OperatorDematerialize() { 
+        // singleton
+    }
+    
     @Override
     public Subscriber<? super Notification<T>> call(final Subscriber<? super T> child) {
         return new Subscriber<Notification<T>>(child) {
@@ -62,6 +65,9 @@ public void onNext(Notification<T> t) {
                 case OnCompleted:
                     onCompleted();
                     break;
+                default:
+                    onError(new IllegalArgumentException("Unsupported notification type: " + t));
+                    break;
                 }
             }
 
diff --git a/src/main/java/rx/internal/operators/OperatorDistinct.java b/src/main/java/rx/internal/operators/OperatorDistinct.java
index a581b1b1e0..716353e272 100644
--- a/src/main/java/rx/internal/operators/OperatorDistinct.java
+++ b/src/main/java/rx/internal/operators/OperatorDistinct.java
@@ -32,7 +32,7 @@
 public final class OperatorDistinct<T, U> implements Operator<T, T> {
     final Func1<? super T, ? extends U> keySelector;
     
-    private static class Holder {
+    static final class Holder {
         static final OperatorDistinct<?,?> INSTANCE = new OperatorDistinct<Object,Object>(UtilityFunctions.<Object>identity());
     }
     
diff --git a/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java b/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
index 43529df76f..9d75db915d 100644
--- a/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
+++ b/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
@@ -31,7 +31,7 @@ public final class OperatorDistinctUntilChanged<T, U> implements Operator<T, T>,
     
     final Func2<? super U, ? super U, Boolean> comparator;
     
-    private static class Holder {
+    static final class Holder {
         static final OperatorDistinctUntilChanged<?,?> INSTANCE = new OperatorDistinctUntilChanged<Object,Object>(UtilityFunctions.identity());
     }
     
@@ -72,14 +72,14 @@ public Subscriber<? super T> call(final Subscriber<? super T> child) {
             boolean hasPrevious;
             @Override
             public void onNext(T t) {
-                U currentKey = previousKey;
-                final U key;
+                U key;
                 try {
                     key = keySelector.call(t);
                 } catch (Throwable e) {
                     Exceptions.throwOrReport(e, child, t);
                     return;
                 }
+                U currentKey = previousKey;
                 previousKey = key;
                 
                 if (hasPrevious) {
diff --git a/src/main/java/rx/internal/operators/OperatorDoOnEach.java b/src/main/java/rx/internal/operators/OperatorDoOnEach.java
index e0e71a2188..0e3034a425 100644
--- a/src/main/java/rx/internal/operators/OperatorDoOnEach.java
+++ b/src/main/java/rx/internal/operators/OperatorDoOnEach.java
@@ -36,7 +36,7 @@ public OperatorDoOnEach(Observer<? super T> doOnEachObserver) {
     public Subscriber<? super T> call(final Subscriber<? super T> observer) {
         return new Subscriber<T>(observer) {
 
-            private boolean done = false;
+            private boolean done;
 
             @Override
             public void onCompleted() {
diff --git a/src/main/java/rx/internal/operators/OperatorDoOnRequest.java b/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
index d45e895b40..e59d1f04d5 100644
--- a/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
+++ b/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
@@ -53,7 +53,7 @@ public void request(long n) {
         return parent;
     }
 
-    private static final class ParentSubscriber<T> extends Subscriber<T> {
+    static final class ParentSubscriber<T> extends Subscriber<T> {
         private final Subscriber<? super T> child;
 
         ParentSubscriber(Subscriber<? super T> child) {
diff --git a/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java b/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java
index cfa46837b5..a779720396 100644
--- a/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java
+++ b/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java
@@ -73,7 +73,7 @@ static final class EagerOuterSubscriber<T, R> extends Subscriber<T> {
         final int bufferSize;
         final Subscriber<? super R> actual;
         
-        final LinkedList<EagerInnerSubscriber<R>> subscribers;
+        final Queue<EagerInnerSubscriber<R>> subscribers;
         
         volatile boolean done;
         Throwable error;
@@ -131,10 +131,12 @@ public void onNext(T t) {
                 return;
             }
             
-            EagerInnerSubscriber<R> inner = new EagerInnerSubscriber<R>(this, bufferSize);
             if (cancelled) {
                 return;
             }
+            
+            EagerInnerSubscriber<R> inner = new EagerInnerSubscriber<R>(this, bufferSize);
+            
             synchronized (subscribers) {
                 if (cancelled) {
                     return;
@@ -202,7 +204,6 @@ void drain() {
                 if (!empty) {
                     long requestedAmount = requested.get();
                     long emittedAmount = 0L;
-                    boolean unbounded = requestedAmount == Long.MAX_VALUE;
                     
                     Queue<Object> innerQueue = innerSubscriber.queue;
                     boolean innerDone = false;
@@ -235,7 +236,7 @@ void drain() {
                             break;
                         }
                         
-                        if (requestedAmount == 0L) {
+                        if (requestedAmount == emittedAmount) {
                             break;
                         }
                         
@@ -248,16 +249,15 @@ void drain() {
                             return;
                         }
                         
-                        requestedAmount--;
-                        emittedAmount--;
+                        emittedAmount++;
                     }
                     
                     if (emittedAmount != 0L) {
-                        if (!unbounded) {
-                            requested.addAndGet(emittedAmount);
+                        if (requestedAmount != Long.MAX_VALUE) {
+                            BackpressureUtils.produced(requested, emittedAmount);
                         }
                         if (!innerDone) {
-                            innerSubscriber.requestMore(-emittedAmount);
+                            innerSubscriber.requestMore(emittedAmount);
                         }
                     }
                     
diff --git a/src/main/java/rx/internal/operators/OperatorElementAt.java b/src/main/java/rx/internal/operators/OperatorElementAt.java
index 6f79d6a285..3fa581b8d2 100644
--- a/src/main/java/rx/internal/operators/OperatorElementAt.java
+++ b/src/main/java/rx/internal/operators/OperatorElementAt.java
@@ -52,7 +52,7 @@ private OperatorElementAt(int index, T defaultValue, boolean hasDefault) {
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         Subscriber<T> parent = new Subscriber<T>() {
 
-            private int currentIndex = 0;
+            private int currentIndex;
 
             @Override
             public void onNext(T value) {
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index 4ed1a504f3..954b1ac6c5 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -266,10 +266,9 @@ void drain() {
                 }
                 
                 long r = requested.get();
-                boolean unbounded = r == Long.MAX_VALUE;
                 long e = 0L;
                 
-                while (r != 0) {
+                while (e != r) {
                     boolean d = done;
                     
                     GroupedObservable<K, V> t = q.poll();
@@ -286,15 +285,14 @@ void drain() {
 
                     a.onNext(t);
                     
-                    r--;
-                    e--;
+                    e++;
                 }
                 
                 if (e != 0L) {
-                    if (!unbounded) {
-                        requested.addAndGet(e);
+                    if (r != Long.MAX_VALUE) {
+                        BackpressureUtils.produced(requested, e);
                     }
-                    s.request(-e);
+                    s.request(e);
                 }
                 
                 missed = wip.addAndGet(-missed);
@@ -334,14 +332,14 @@ boolean checkTerminated(boolean d, boolean empty,
     }
     
     static final class GroupedUnicast<K, T> extends GroupedObservable<K, T> {
+        final State<T, K> state;
+        
         
         public static <T, K> GroupedUnicast<K, T> createWith(K key, int bufferSize, GroupBySubscriber<?, K, T> parent, boolean delayError) {
             State<T, K> state = new State<T, K>(bufferSize, parent, key, delayError);
             return new GroupedUnicast<K, T>(key, state);
         }
         
-        final State<T, K> state;
-        
         protected GroupedUnicast(K key, State<T, K> state) {
             super(key, state);
             this.state = state;
@@ -381,7 +379,7 @@ static final class State<T, K> extends AtomicInteger implements Producer, Subscr
         final AtomicBoolean once;
 
         
-        public State(int bufferSize, GroupBySubscriber<?, K, T> parent, K key, boolean delayError) {
+        public State(int bufferSize, GroupBySubscriber<?, K, T> parent, K key, boolean delayError) { // NOPMD 
             this.queue = new ConcurrentLinkedQueue<Object>();
             this.parent = parent;
             this.key = key;
@@ -467,10 +465,9 @@ void drain() {
                     }
                     
                     long r = requested.get();
-                    boolean unbounded = r == Long.MAX_VALUE;
                     long e = 0;
                     
-                    while (r != 0L) {
+                    while (e != r) {
                         boolean d = done;
                         Object v = q.poll();
                         boolean empty = v == null;
@@ -485,15 +482,14 @@ void drain() {
                         
                         a.onNext(nl.getValue(v));
                         
-                        r--;
-                        e--;
+                        e++;
                     }
                     
                     if (e != 0L) {
-                        if (!unbounded) {
-                            requested.addAndGet(e);
+                        if (r != Long.MAX_VALUE) {
+                            BackpressureUtils.produced(requested, e);
                         }
-                        parent.s.request(-e);
+                        parent.s.request(e);
                     }
                 }
                 
diff --git a/src/main/java/rx/internal/operators/OperatorIgnoreElements.java b/src/main/java/rx/internal/operators/OperatorIgnoreElements.java
index 00098f85a2..b85fb54359 100644
--- a/src/main/java/rx/internal/operators/OperatorIgnoreElements.java
+++ b/src/main/java/rx/internal/operators/OperatorIgnoreElements.java
@@ -20,7 +20,7 @@
 
 public class OperatorIgnoreElements<T> implements Operator<T, T> {
 
-    private static class Holder {
+    static final class Holder {
         static final OperatorIgnoreElements<?> INSTANCE = new OperatorIgnoreElements<Object>();
     }
     
@@ -30,7 +30,7 @@ public static <T> OperatorIgnoreElements<T> instance() {
     }
 
     OperatorIgnoreElements() {
-
+        // singleton
     }
 
     @Override
diff --git a/src/main/java/rx/internal/operators/OperatorMapPair.java b/src/main/java/rx/internal/operators/OperatorMapPair.java
index 5db9596b6b..a9733c7d88 100644
--- a/src/main/java/rx/internal/operators/OperatorMapPair.java
+++ b/src/main/java/rx/internal/operators/OperatorMapPair.java
@@ -34,6 +34,8 @@
  *            the type of items to be emitted by this {@code Operator}
  */
 public final class OperatorMapPair<T, U, R> implements Operator<Observable<? extends R>, T> {
+    final Func1<? super T, ? extends Observable<? extends U>> collectionSelector;
+    final Func2<? super T, ? super U, ? extends R> resultSelector;
 
     /**
      * Creates the function that generates a {@code Observable} based on an item emitted by another {@code Observable}.
@@ -54,9 +56,6 @@ public Observable<U> call(T t1) {
         };
     }
 
-    final Func1<? super T, ? extends Observable<? extends U>> collectionSelector;
-    final Func2<? super T, ? super U, ? extends R> resultSelector;
-
     public OperatorMapPair(final Func1<? super T, ? extends Observable<? extends U>> collectionSelector, final Func2<? super T, ? super U, ? extends R> resultSelector) {
         this.collectionSelector = collectionSelector;
         this.resultSelector = resultSelector;
diff --git a/src/main/java/rx/internal/operators/OperatorMaterialize.java b/src/main/java/rx/internal/operators/OperatorMaterialize.java
index 4d01dadf39..aebecf5029 100644
--- a/src/main/java/rx/internal/operators/OperatorMaterialize.java
+++ b/src/main/java/rx/internal/operators/OperatorMaterialize.java
@@ -33,7 +33,7 @@
 public final class OperatorMaterialize<T> implements Operator<Notification<T>, T> {
 
     /** Lazy initialization via inner-class holder. */
-    private static final class Holder {
+    static final class Holder {
         /** A singleton instance. */
         static final OperatorMaterialize<Object> INSTANCE = new OperatorMaterialize<Object>();
     }
@@ -48,6 +48,7 @@ public static <T> OperatorMaterialize<T> instance() {
     }
 
     OperatorMaterialize() {
+        // singleton instances
     }
 
     @Override
@@ -65,16 +66,16 @@ public void request(long n) {
         return parent;
     }
 
-    private static class ParentSubscriber<T> extends Subscriber<T> {
+    static class ParentSubscriber<T> extends Subscriber<T> {
 
         private final Subscriber<? super Notification<T>> child;
 
         private volatile Notification<T> terminalNotification;
         
         // guarded by this
-        private boolean busy = false;
+        private boolean busy;
         // guarded by this
-        private boolean missed = false;
+        private boolean missed;
 
         private final AtomicLong requested = new AtomicLong();
 
diff --git a/src/main/java/rx/internal/operators/OperatorMerge.java b/src/main/java/rx/internal/operators/OperatorMerge.java
index 3391d18cd8..71d74713bf 100644
--- a/src/main/java/rx/internal/operators/OperatorMerge.java
+++ b/src/main/java/rx/internal/operators/OperatorMerge.java
@@ -53,13 +53,16 @@
  *            the type of the items emitted by both the source and merged {@code Observable}s
  */
 public final class OperatorMerge<T> implements Operator<T, Observable<? extends T>> {
+    final boolean delayErrors;
+    final int maxConcurrent;
+
     /** Lazy initialization via inner-class holder. */
-    private static final class HolderNoDelay {
+    static final class HolderNoDelay {
         /** A singleton instance. */
         static final OperatorMerge<Object> INSTANCE = new OperatorMerge<Object>(false, Integer.MAX_VALUE);
     }
     /** Lazy initialization via inner-class holder. */
-    private static final class HolderDelayErrors {
+    static final class HolderDelayErrors {
         /** A singleton instance. */
         static final OperatorMerge<Object> INSTANCE = new OperatorMerge<Object>(true, Integer.MAX_VALUE);
     }
@@ -92,9 +95,6 @@ public static <T> OperatorMerge<T> instance(boolean delayErrors, int maxConcurre
         return new OperatorMerge<T>(delayErrors, maxConcurrent);
     }
 
-    final boolean delayErrors;
-    final int maxConcurrent;
-
     OperatorMerge(boolean delayErrors, int maxConcurrent) {
         this.delayErrors = delayErrors;
         this.maxConcurrent = maxConcurrent;
@@ -824,7 +824,7 @@ static final class InnerSubscriber<T> extends Subscriber<T> {
         volatile boolean done;
         volatile RxRingBuffer queue;
         int outstanding;
-        static final int limit = RxRingBuffer.SIZE / 4;
+        static final int LIMIT = RxRingBuffer.SIZE / 4;
         
         public InnerSubscriber(MergeSubscriber<T> parent, long id) {
             this.parent = parent;
@@ -852,7 +852,7 @@ public void onCompleted() {
         }
         public void requestMore(long n) {
             int r = outstanding - (int)n;
-            if (r > limit) {
+            if (r > LIMIT) {
                 outstanding = r;
                 return;
             }
diff --git a/src/main/java/rx/internal/operators/OperatorMulticast.java b/src/main/java/rx/internal/operators/OperatorMulticast.java
index ee5551fcef..965b850f5d 100644
--- a/src/main/java/rx/internal/operators/OperatorMulticast.java
+++ b/src/main/java/rx/internal/operators/OperatorMulticast.java
@@ -104,8 +104,9 @@ public void call() {
                                 subscription = null;
                                 guardedSubscription = null;
                                 connectedSubject.set(null);
-                            } else 
+                            } else {
                                 return;
+                            }
                         }
                         if (s != null) {
                             s.unsubscribe();
@@ -149,7 +150,8 @@ public void onCompleted() {
         synchronized (guard) {
             sub = subscription;
         }
-        if (sub != null)
+        if (sub != null) {
             ((Observable<T>)source).subscribe(sub);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/main/java/rx/internal/operators/OperatorObserveOn.java b/src/main/java/rx/internal/operators/OperatorObserveOn.java
index 42fc5518ae..57145ec27a 100644
--- a/src/main/java/rx/internal/operators/OperatorObserveOn.java
+++ b/src/main/java/rx/internal/operators/OperatorObserveOn.java
@@ -89,7 +89,7 @@ public Subscriber<? super T> call(Subscriber<? super T> child) {
     }
 
     /** Observe through individual queue per observer. */
-    private static final class ObserveOnSubscriber<T> extends Subscriber<T> implements Action0 {
+    static final class ObserveOnSubscriber<T> extends Subscriber<T> implements Action0 {
         final Subscriber<? super T> child;
         final Scheduler.Worker recursiveScheduler;
         final NotificationLite<T> on;
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
index 04e6e81be9..8c14a70334 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
@@ -19,7 +19,6 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 
-import rx.BackpressureOverflow;
 import rx.Observable.Operator;
 import rx.Producer;
 import rx.Subscriber;
@@ -34,9 +33,9 @@ public class OperatorOnBackpressureBuffer<T> implements Operator<T, T> {
 
     private final Long capacity;
     private final Action0 onOverflow;
-    private final BackpressureOverflow.Strategy overflowStrategy;
+    private final Strategy overflowStrategy;
 
-    private static class Holder {
+    static final class Holder {
         static final OperatorOnBackpressureBuffer<?> INSTANCE = new OperatorOnBackpressureBuffer<Object>();
     }
 
@@ -80,7 +79,7 @@ public OperatorOnBackpressureBuffer(long capacity, Action0 onOverflow) {
      * @param overflowStrategy the {@code BackpressureOverflow.Strategy} to handle overflows, it must not be null.
      */
     public OperatorOnBackpressureBuffer(long capacity, Action0 onOverflow,
-                                        BackpressureOverflow.Strategy overflowStrategy) {
+                                        Strategy overflowStrategy) {
         if (capacity <= 0) {
             throw new IllegalArgumentException("Buffer capacity must be > 0");
         }
@@ -107,7 +106,7 @@ public Subscriber<? super T> call(final Subscriber<? super T> child) {
         return parent;
     }
 
-    private static final class BufferSubscriber<T> extends Subscriber<T> implements BackpressureDrainManager.BackpressureQueueCallback {
+    static final class BufferSubscriber<T> extends Subscriber<T> implements BackpressureDrainManager.BackpressureQueueCallback {
         // TODO get a different queue implementation
         private final ConcurrentLinkedQueue<Object> queue = new ConcurrentLinkedQueue<Object>();
         private final AtomicLong capacity;
@@ -116,10 +115,10 @@ private static final class BufferSubscriber<T> extends Subscriber<T> implements
         private final BackpressureDrainManager manager;
         private final NotificationLite<T> on = NotificationLite.instance();
         private final Action0 onOverflow;
-        private final BackpressureOverflow.Strategy overflowStrategy;
+        private final Strategy overflowStrategy;
         
         public BufferSubscriber(final Subscriber<? super T> child, Long capacity, Action0 onOverflow,
-                                BackpressureOverflow.Strategy overflowStrategy) {
+                                Strategy overflowStrategy) {
             this.child = child;
             this.capacity = capacity != null ? new AtomicLong(capacity) : null;
             this.onOverflow = onOverflow;
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
index 98f4f9479d..63e13da125 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
@@ -25,8 +25,10 @@
 
 public class OperatorOnBackpressureDrop<T> implements Operator<T, T> {
 
+    final Action1<? super T> onDrop;
+
     /** Lazy initialization via inner-class holder. */
-    private static final class Holder {
+    static final class Holder {
         /** A singleton instance. */
         static final OperatorOnBackpressureDrop<Object> INSTANCE = new OperatorOnBackpressureDrop<Object>();
     }
@@ -40,8 +42,6 @@ public static <T> OperatorOnBackpressureDrop<T> instance() {
         return (OperatorOnBackpressureDrop<T>)Holder.INSTANCE;
     }
 
-    final Action1<? super T> onDrop;
-
     OperatorOnBackpressureDrop() {
         this(null);
     }
diff --git a/src/main/java/rx/internal/operators/OperatorPublish.java b/src/main/java/rx/internal/operators/OperatorPublish.java
index 1e5002e116..1d5781a39f 100644
--- a/src/main/java/rx/internal/operators/OperatorPublish.java
+++ b/src/main/java/rx/internal/operators/OperatorPublish.java
@@ -109,7 +109,7 @@ public void call(Subscriber<? super T> child) {
                     // setting the producer will trigger the first request to be considered by 
                     // the subscriber-to-source.
                     child.setProducer(inner);
-                    break;
+                    break; // NOPMD 
                 }
             }
         };
@@ -194,7 +194,7 @@ public void connect(Action1<? super Subscription> connection) {
             // if connect() was called concurrently, only one of them should actually 
             // connect to the source
             doConnect = !ps.shouldConnect.get() && ps.shouldConnect.compareAndSet(false, true);
-            break;
+            break; // NOPMD 
         }
         /* 
          * Notify the callback that we have a (new) connection which it can unsubscribe
diff --git a/src/main/java/rx/internal/operators/OperatorReplay.java b/src/main/java/rx/internal/operators/OperatorReplay.java
index 84338b96f9..86774cbd39 100644
--- a/src/main/java/rx/internal/operators/OperatorReplay.java
+++ b/src/main/java/rx/internal/operators/OperatorReplay.java
@@ -210,7 +210,7 @@ public void call(Subscriber<? super T> child) {
                     // if there isn't one
                     if (r == null) {
                         // create a new subscriber to source
-                        ReplaySubscriber<T> u = new ReplaySubscriber<T>(curr, bufferFactory.call());
+                        ReplaySubscriber<T> u = new ReplaySubscriber<T>(bufferFactory.call());
                         // perform extra initialization to avoid 'this' to escape during construction
                         u.init();
                         // let's try setting it as the current subscriber-to-source
@@ -239,7 +239,7 @@ public void call(Subscriber<? super T> child) {
                     // setting the producer will trigger the first request to be considered by 
                     // the subscriber-to-source.
                     child.setProducer(inner);
-                    break;
+                    break; // NOPMD 
                 }
             }
         };
@@ -265,7 +265,7 @@ public void connect(Action1<? super Subscription> connection) {
             // if there is none yet or the current has unsubscribed
             if (ps == null || ps.isUnsubscribed()) {
                 // create a new subscriber-to-source
-                ReplaySubscriber<T> u = new ReplaySubscriber<T>(current, bufferFactory.call());
+                ReplaySubscriber<T> u = new ReplaySubscriber<T>(bufferFactory.call());
                 // initialize out the constructor to avoid 'this' to escape
                 u.init();
                 // try setting it as the current subscriber-to-source
@@ -279,7 +279,7 @@ public void connect(Action1<? super Subscription> connection) {
             // if connect() was called concurrently, only one of them should actually 
             // connect to the source
             doConnect = !ps.shouldConnect.get() && ps.shouldConnect.compareAndSet(false, true);
-            break;
+            break; // NOPMD 
         }
         /* 
          * Notify the callback that we have a (new) connection which it can unsubscribe
@@ -349,8 +349,7 @@ static final class ReplaySubscriber<T> extends Subscriber<T> implements Subscrip
         boolean coordinateAll;
         
         @SuppressWarnings("unchecked")
-        public ReplaySubscriber(AtomicReference<ReplaySubscriber<T>> current,
-                ReplayBuffer<T> buffer) {
+        public ReplaySubscriber(ReplayBuffer<T> buffer) {
             this.buffer = buffer;
             
             this.nl = NotificationLite.instance();
@@ -880,10 +879,9 @@ public void replay(InnerProducer<T> output) {
                 int destIndex = destIndexObject != null ? destIndexObject : 0;
                 
                 long r = output.get();
-                long r0 = r;
                 long e = 0L;
                 
-                while (r != 0L && destIndex < sourceIndex) {
+                while (e != r && destIndex < sourceIndex) {
                     Object o = get(destIndex);
                     try {
                         if (nl.accept(output.child, o)) {
@@ -901,12 +899,11 @@ public void replay(InnerProducer<T> output) {
                         return;
                     }
                     destIndex++;
-                    r--;
                     e++;
                 }
                 if (e != 0L) {
                     output.index = destIndex;
-                    if (r0 != Long.MAX_VALUE) {
+                    if (r != Long.MAX_VALUE) {
                         output.produced(e);
                     }
                 }
@@ -1053,10 +1050,6 @@ public final void replay(InnerProducer<T> output) {
                     return;
                 }
 
-                long r = output.get();
-                boolean unbounded = r == Long.MAX_VALUE;
-                long e = 0L;
-                
                 Node node = output.index();
                 if (node == null) {
                     node = getInitialHead();
@@ -1073,7 +1066,10 @@ public final void replay(InnerProducer<T> output) {
                     return;
                 }
 
-                while (r != 0) {
+                long r = output.get();
+                long e = 0L;
+
+                while (e != r) {
                     Node v = node.get();
                     if (v != null) {
                         Object o = leaveTransform(v.value);
@@ -1092,7 +1088,6 @@ public final void replay(InnerProducer<T> output) {
                             return;
                         }
                         e++;
-                        r--;
                         node = v;
                     } else {
                         break;
@@ -1104,7 +1099,7 @@ public final void replay(InnerProducer<T> output) {
 
                 if (e != 0L) {
                     output.index = node;
-                    if (!unbounded) {
+                    if (r != Long.MAX_VALUE) {
                         output.produced(e);
                     }
                 }
@@ -1143,14 +1138,14 @@ Object leaveTransform(Object value) {
          * based on its current properties.
          */
         void truncate() {
-            
+            // no op by default
         }
         /**
          * Override this method to truncate a terminated buffer
          * based on its properties (i.e., truncate but the very last node).
          */
         void truncateFinal() {
-            
+            // no op by default
         }
         /* test */ final  void collect(Collection<? super T> output) {
             Node n = getInitialHead();
diff --git a/src/main/java/rx/internal/operators/OperatorScan.java b/src/main/java/rx/internal/operators/OperatorScan.java
index 547edf5c1b..e386c6cb16 100644
--- a/src/main/java/rx/internal/operators/OperatorScan.java
+++ b/src/main/java/rx/internal/operators/OperatorScan.java
@@ -303,14 +303,13 @@ void emitLoop() {
             
             long r = requested.get();
             for (;;) {
-                boolean max = r == Long.MAX_VALUE;
                 boolean d = done;
                 boolean empty = queue.isEmpty();
                 if (checkTerminated(d, empty, child)) {
                     return;
                 }
                 long e = 0L;
-                while (r != 0L) {
+                while (e != r) {
                     d = done;
                     Object o = queue.poll();
                     empty = o == null;
@@ -327,12 +326,11 @@ void emitLoop() {
                         Exceptions.throwOrReport(ex, child, v);
                         return;
                     }
-                    r--;
-                    e--;
+                    e++;
                 }
                 
-                if (e != 0 && !max) {
-                    r = requested.addAndGet(e);
+                if (e != 0 && r != Long.MAX_VALUE) {
+                    r = BackpressureUtils.produced(requested, e);
                 }
                 
                 synchronized (this) {
diff --git a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
index 53deb16edf..05ad83bdc9 100644
--- a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
+++ b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
@@ -28,12 +28,14 @@
  * {@code Observable}s emit sequences of items that are equivalent to each other.
  */
 public final class OperatorSequenceEqual {
+
+    /** NotificationLite doesn't work as zip uses it. */
+    static final Object LOCAL_ONCOMPLETED = new Object();
+
     private OperatorSequenceEqual() {
         throw new IllegalStateException("No instances!");
     }
 
-    /** NotificationLite doesn't work as zip uses it. */
-    static final Object LOCAL_ONCOMPLETED = new Object();
     static <T> Observable<Object> materializeLite(Observable<T> source) {
         return concat(
                 source.map(new Func1<T, Object>() {
diff --git a/src/main/java/rx/internal/operators/OperatorSerialize.java b/src/main/java/rx/internal/operators/OperatorSerialize.java
index 9c313f450e..2ceada9b71 100644
--- a/src/main/java/rx/internal/operators/OperatorSerialize.java
+++ b/src/main/java/rx/internal/operators/OperatorSerialize.java
@@ -21,7 +21,7 @@
 
 public final class OperatorSerialize<T> implements Operator<T, T> {
     /** Lazy initialization via inner-class holder. */
-    private static final class Holder {
+    static final class Holder {
         /** A singleton instance. */
         static final OperatorSerialize<Object> INSTANCE = new OperatorSerialize<Object>();
     }
@@ -33,7 +33,11 @@ private static final class Holder {
     public static <T> OperatorSerialize<T> instance() {
         return (OperatorSerialize<T>)Holder.INSTANCE;
     }
-    OperatorSerialize() { }
+    
+    OperatorSerialize() { 
+        // singleton
+    }
+    
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> s) {
         return new SerializedSubscriber<T>(new Subscriber<T>(s) {
diff --git a/src/main/java/rx/internal/operators/OperatorSingle.java b/src/main/java/rx/internal/operators/OperatorSingle.java
index 2ecdbfecb0..7984d06786 100644
--- a/src/main/java/rx/internal/operators/OperatorSingle.java
+++ b/src/main/java/rx/internal/operators/OperatorSingle.java
@@ -33,7 +33,7 @@ public final class OperatorSingle<T> implements Operator<T, T> {
     private final boolean hasDefaultValue;
     private final T defaultValue;
 
-    private static class Holder {
+    static final class Holder {
         final static OperatorSingle<?> INSTANCE = new OperatorSingle<Object>();
     }
     
@@ -71,7 +71,7 @@ public Subscriber<? super T> call(final Subscriber<? super T> child) {
         return parent;
     }
 
-    private static final class ParentSubscriber<T> extends Subscriber<T> {
+    static final class ParentSubscriber<T> extends Subscriber<T> {
         private final Subscriber<? super T> child;
         private final boolean hasDefaultValue;
         private final T defaultValue;
diff --git a/src/main/java/rx/internal/operators/OperatorSkip.java b/src/main/java/rx/internal/operators/OperatorSkip.java
index 6b06fe47b4..cdd0511075 100644
--- a/src/main/java/rx/internal/operators/OperatorSkip.java
+++ b/src/main/java/rx/internal/operators/OperatorSkip.java
@@ -42,7 +42,7 @@ public OperatorSkip(int n) {
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         return new Subscriber<T>(child) {
 
-            int skipped = 0;
+            int skipped;
 
             @Override
             public void onCompleted() {
diff --git a/src/main/java/rx/internal/operators/OperatorSkipWhile.java b/src/main/java/rx/internal/operators/OperatorSkipWhile.java
index b62e7f24a5..328c2a7b4b 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipWhile.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipWhile.java
@@ -42,7 +42,7 @@ public void onNext(T t) {
                 if (!skipping) {
                     child.onNext(t);
                 } else {
-                    final boolean skip;
+                    boolean skip;
                     try {
                         skip = predicate.call(t,  index++);
                     } catch (Throwable e) {
diff --git a/src/main/java/rx/internal/operators/OperatorSwitch.java b/src/main/java/rx/internal/operators/OperatorSwitch.java
index c76e3008c9..8c8be1dbec 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitch.java
+++ b/src/main/java/rx/internal/operators/OperatorSwitch.java
@@ -37,13 +37,14 @@
  * @param <T> the value type
  */
 public final class OperatorSwitch<T> implements Operator<T, Observable<? extends T>> {
+    final boolean delayError;
     /** Lazy initialization via inner-class holder. */
-    private static final class Holder {
+    static final class Holder {
         /** A singleton instance. */
         static final OperatorSwitch<Object> INSTANCE = new OperatorSwitch<Object>(false);
     }
     /** Lazy initialization via inner-class holder. */
-    private static final class HolderDelayError {
+    static final class HolderDelayError {
         /** A singleton instance. */
         static final OperatorSwitch<Object> INSTANCE = new OperatorSwitch<Object>(true);
     }
@@ -61,8 +62,6 @@ public static <T> OperatorSwitch<T> instance(boolean delayError) {
         return (OperatorSwitch<T>)Holder.INSTANCE;
     }
 
-    final boolean delayError;
-    
     OperatorSwitch(boolean delayError) { 
         this.delayError = delayError;
     }
@@ -75,7 +74,7 @@ public Subscriber<? super Observable<? extends T>> call(final Subscriber<? super
         return sws;
     }
 
-    private static final class SwitchSubscriber<T> extends Subscriber<Observable<? extends T>> {
+    static final class SwitchSubscriber<T> extends Subscriber<Observable<? extends T>> {
         final Subscriber<? super T> child;
         final SerialSubscription ssub;
         final boolean delayError;
@@ -267,7 +266,6 @@ void childRequested(long n) {
         }
         
         void drain() {
-            boolean localMainDone = mainDone;
             boolean localInnerActive;
             long localRequested;
             Throwable localError;
@@ -288,6 +286,7 @@ void drain() {
             final SpscLinkedArrayQueue<Object> localQueue = queue;
             final AtomicLong localIndex = index;
             final Subscriber<? super T> localChild = child;
+            boolean localMainDone = mainDone;
 
             for (;;) {
 
diff --git a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java b/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
index 40b44289b7..890f18cebf 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
+++ b/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
@@ -44,7 +44,7 @@ public Subscriber<? super T> call(Subscriber<? super T> child) {
         return parent;
     }
 
-    private static final class ParentSubscriber<T> extends Subscriber<T> {
+    static final class ParentSubscriber<T> extends Subscriber<T> {
 
         private boolean empty = true;
         private final Subscriber<? super T> child;
@@ -92,7 +92,7 @@ public void onNext(T t) {
         }
     }
     
-    private static final class AlternateSubscriber<T> extends Subscriber<T> {
+    static final class AlternateSubscriber<T> extends Subscriber<T> {
         
         private final ProducerArbiter arbiter;
         private final Subscriber<? super T> child;
diff --git a/src/main/java/rx/internal/operators/OperatorTake.java b/src/main/java/rx/internal/operators/OperatorTake.java
index d08c5a3b92..c8b600acfc 100644
--- a/src/main/java/rx/internal/operators/OperatorTake.java
+++ b/src/main/java/rx/internal/operators/OperatorTake.java
@@ -104,9 +104,9 @@ public void request(long n) {
                             while (true) {
                                 long r = requested.get();
                                 long c = Math.min(n, limit - r);
-                                if (c == 0)
+                                if (c == 0) {
                                     break;
-                                else if (requested.compareAndSet(r, r + c)) {
+                                } else if (requested.compareAndSet(r, r + c)) {
                                     producer.request(c);
                                     break;
                                 }
diff --git a/src/main/java/rx/internal/operators/OperatorTakeLastOne.java b/src/main/java/rx/internal/operators/OperatorTakeLastOne.java
index 2c20f2a465..a1ab397ba5 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeLastOne.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeLastOne.java
@@ -25,7 +25,7 @@
 
 public class OperatorTakeLastOne<T> implements Operator<T, T> {
 
-    private static class Holder {
+    static final class Holder {
         static final OperatorTakeLastOne<Object> INSTANCE = new OperatorTakeLastOne<Object>();
     }
 
@@ -35,7 +35,7 @@ public static <T> OperatorTakeLastOne<T> instance() {
     }
 
     OperatorTakeLastOne() {
-
+        // singleton
     }
 
     @Override
@@ -52,7 +52,7 @@ public void request(long n) {
         return parent;
     }
 
-    private static class ParentSubscriber<T> extends Subscriber<T> {
+    static final class ParentSubscriber<T> extends Subscriber<T> {
 
         private final static int NOT_REQUESTED_NOT_COMPLETED = 0;
         private final static int NOT_REQUESTED_COMPLETED = 1;
@@ -109,9 +109,10 @@ void requestMore(long n) {
                             emit();
                             return;
                         }
-                    } else
+                    } else {
                         // already requested so we exit
                         return;
+                    }
                 }
             }
         }
@@ -141,9 +142,10 @@ public void onCompleted() {
                         emit();
                         return;
                     }
-                } else
+                } else {
                     // already completed so we exit
                     return;
+                }
             }
         }
 
@@ -171,8 +173,9 @@ private void emit() {
                     return;
                 }
             }
-            if (!isUnsubscribed())
+            if (!isUnsubscribed()) {
                 child.onCompleted();
+            }
         }
 
         @Override
diff --git a/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java b/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
index 8ed22f9108..0b19f2e051 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
@@ -27,10 +27,30 @@
  * @param <T> the value type
  */
 public final class OperatorTakeUntilPredicate<T> implements Operator<T, T> {
+    final Func1<? super T, Boolean> stopPredicate;
+
+    public OperatorTakeUntilPredicate(final Func1<? super T, Boolean> stopPredicate) {
+        this.stopPredicate = stopPredicate;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        final ParentSubscriber parent = new ParentSubscriber(child);
+        child.add(parent); // don't unsubscribe downstream
+        child.setProducer(new Producer() {
+            @Override
+            public void request(long n) {
+                parent.downstreamRequest(n);
+            }
+        });
+        
+        return parent;
+    }
+
     /** Subscriber returned to the upstream. */
-    private final class ParentSubscriber extends Subscriber<T> {
+    final class ParentSubscriber extends Subscriber<T> {
         private final Subscriber<? super T> child;
-        private boolean done = false;
+        private boolean done;
 
         ParentSubscriber(Subscriber<? super T> child) {
             this.child = child;
@@ -73,25 +93,4 @@ void downstreamRequest(long n) {
             request(n);
         }
     }
-
-    final Func1<? super T, Boolean> stopPredicate;
-
-    public OperatorTakeUntilPredicate(final Func1<? super T, Boolean> stopPredicate) {
-        this.stopPredicate = stopPredicate;
-    }
-
-    @Override
-    public Subscriber<? super T> call(final Subscriber<? super T> child) {
-        final ParentSubscriber parent = new ParentSubscriber(child);
-        child.add(parent); // don't unsubscribe downstream
-        child.setProducer(new Producer() {
-            @Override
-            public void request(long n) {
-                parent.downstreamRequest(n);
-            }
-        });
-        
-        return parent;
-    }
-
 }
diff --git a/src/main/java/rx/internal/operators/OperatorTakeWhile.java b/src/main/java/rx/internal/operators/OperatorTakeWhile.java
index 2a5fdc5bc0..c444627819 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeWhile.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeWhile.java
@@ -48,9 +48,9 @@ public OperatorTakeWhile(Func2<? super T, ? super Integer, Boolean> predicate) {
     public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
         Subscriber<T> s = new Subscriber<T>(subscriber, false) {
 
-            private int counter = 0;
+            private int counter;
 
-            private boolean done = false;
+            private boolean done;
 
             @Override
             public void onNext(T t) {
diff --git a/src/main/java/rx/internal/operators/OperatorThrottleFirst.java b/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
index 906b207856..b7a368578b 100644
--- a/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
+++ b/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
@@ -38,7 +38,7 @@ public OperatorThrottleFirst(long windowDuration, TimeUnit unit, Scheduler sched
     public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
         return new Subscriber<T>(subscriber) {
 
-            private long lastOnNext = 0;
+            private long lastOnNext;
 
             @Override
             public void onStart() {
diff --git a/src/main/java/rx/internal/operators/OperatorTimeoutBase.java b/src/main/java/rx/internal/operators/OperatorTimeoutBase.java
index 823831bc3a..d2fcc2a0ef 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeoutBase.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeoutBase.java
@@ -25,6 +25,10 @@
 import rx.subscriptions.SerialSubscription;
 
 class OperatorTimeoutBase<T> implements Operator<T, T> {
+    final FirstTimeoutStub<T> firstTimeoutStub;
+    final TimeoutStub<T> timeoutStub;
+    final Observable<? extends T> other;
+    final Scheduler scheduler;
 
     /**
      * Set up the timeout action on the first value.
@@ -44,11 +48,6 @@ class OperatorTimeoutBase<T> implements Operator<T, T> {
             Func4<TimeoutSubscriber<T>, Long, T, Scheduler.Worker, Subscription> {
     }
 
-    final FirstTimeoutStub<T> firstTimeoutStub;
-    final TimeoutStub<T> timeoutStub;
-    final Observable<? extends T> other;
-    final Scheduler scheduler;
-
     /* package-private */OperatorTimeoutBase(FirstTimeoutStub<T> firstTimeoutStub, TimeoutStub<T> timeoutStub, Observable<? extends T> other, Scheduler scheduler) {
         this.firstTimeoutStub = firstTimeoutStub;
         this.timeoutStub = timeoutStub;
diff --git a/src/main/java/rx/internal/operators/OperatorToMap.java b/src/main/java/rx/internal/operators/OperatorToMap.java
index aa82c49cc4..725340982a 100644
--- a/src/main/java/rx/internal/operators/OperatorToMap.java
+++ b/src/main/java/rx/internal/operators/OperatorToMap.java
@@ -37,6 +37,12 @@
  */
 public final class OperatorToMap<T, K, V> implements Operator<Map<K, V>, T> {
 
+    final Func1<? super T, ? extends K> keySelector;
+
+    final Func1<? super T, ? extends V> valueSelector;
+
+    private final Func0<? extends Map<K, V>> mapFactory;
+
     /**
      * The default map factory.
      * @param <K> the key type
@@ -49,14 +55,6 @@ public Map<K, V> call() {
         }
     }
 
-
-    final Func1<? super T, ? extends K> keySelector;
-
-    final Func1<? super T, ? extends V> valueSelector;
-
-    private final Func0<? extends Map<K, V>> mapFactory;
-
-
     /**
      * ToMap with key selector, value selector and default HashMap factory.
      * @param keySelector the function extracting the map-key from the main value
diff --git a/src/main/java/rx/internal/operators/OperatorToMultimap.java b/src/main/java/rx/internal/operators/OperatorToMultimap.java
index fe753fee95..10e1cbb373 100644
--- a/src/main/java/rx/internal/operators/OperatorToMultimap.java
+++ b/src/main/java/rx/internal/operators/OperatorToMultimap.java
@@ -39,6 +39,12 @@
  * @param <V> the multimap-value type
  */
 public final class OperatorToMultimap<T, K, V> implements Operator<Map<K, Collection<V>>, T> {
+
+    final Func1<? super T, ? extends K> keySelector;
+    final Func1<? super T, ? extends V> valueSelector;
+    private final Func0<? extends Map<K, Collection<V>>> mapFactory;
+    final Func1<? super K, ? extends Collection<V>> collectionFactory;
+
     /**
      * The default multimap factory returning a HashMap.
      * @param <K> the key type
@@ -65,11 +71,6 @@ public Collection<V> call(K t1) {
         }
     }
 
-    final Func1<? super T, ? extends K> keySelector;
-    final Func1<? super T, ? extends V> valueSelector;
-    private final Func0<? extends Map<K, Collection<V>>> mapFactory;
-    final Func1<? super K, ? extends Collection<V>> collectionFactory;
-
     /**
      * ToMultimap with key selector, custom value selector,
      * default HashMap factory and default ArrayList collection factory.
diff --git a/src/main/java/rx/internal/operators/OperatorToObservableList.java b/src/main/java/rx/internal/operators/OperatorToObservableList.java
index 518a9a37c1..bde9947eaa 100644
--- a/src/main/java/rx/internal/operators/OperatorToObservableList.java
+++ b/src/main/java/rx/internal/operators/OperatorToObservableList.java
@@ -39,7 +39,7 @@
  */
 public final class OperatorToObservableList<T> implements Operator<List<T>, T> {
     /** Lazy initialization via inner-class holder. */
-    private static final class Holder {
+    static final class Holder {
         /** A singleton instance. */
         static final OperatorToObservableList<Object> INSTANCE = new OperatorToObservableList<Object>();
     }
@@ -51,13 +51,16 @@ private static final class Holder {
     public static <T> OperatorToObservableList<T> instance() {
         return (OperatorToObservableList<T>)Holder.INSTANCE;
     }
-    OperatorToObservableList() { }
+    OperatorToObservableList() { 
+        // singleton
+    }
+    
     @Override
     public Subscriber<? super T> call(final Subscriber<? super List<T>> o) {
         final SingleDelayedProducer<List<T>> producer = new SingleDelayedProducer<List<T>>(o);
         Subscriber<T> result =  new Subscriber<T>() {
 
-            boolean completed = false;
+            boolean completed;
             List<T> list = new LinkedList<T>();
 
             @Override
diff --git a/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java b/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java
index ab74e44f17..72c1536a22 100644
--- a/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java
+++ b/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java
@@ -36,6 +36,9 @@
 public final class OperatorToObservableSortedList<T> implements Operator<List<T>, T> {
     final Comparator<? super T> sortFunction;
     final int initialCapacity;
+    // raw because we want to support Object for this default
+    @SuppressWarnings("rawtypes")
+    private static final Comparator DEFAULT_SORT_FUNCTION = new DefaultComparableFunction();
 
     @SuppressWarnings("unchecked")
     public OperatorToObservableSortedList(int initialCapacity) {
@@ -100,13 +103,8 @@ public void onNext(T value) {
         child.setProducer(producer);
         return result;
     }
-    // raw because we want to support Object for this default
-    @SuppressWarnings("rawtypes")
-    private static Comparator DEFAULT_SORT_FUNCTION = new DefaultComparableFunction();
 
-    private static class DefaultComparableFunction implements Comparator<Object> {
-        DefaultComparableFunction() {
-        }
+    static final class DefaultComparableFunction implements Comparator<Object> {
 
         // unchecked because we want to support Object for this default
         @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java b/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
index 6d7324bf9f..616e644c8c 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
@@ -33,6 +33,10 @@
  */
 public final class OperatorWindowWithObservable<T, U> implements Operator<Observable<T>, T> {
     final Observable<U> other;
+    /** Indicate the current subject should complete and a new subject be emitted. */
+    static final Object NEXT_SUBJECT = new Object();
+    /** For error and completion indication. */
+    static final NotificationLite<Object> NL = NotificationLite.instance();
 
     public OperatorWindowWithObservable(final Observable<U> other) {
         this.other = other;
@@ -42,7 +46,7 @@ public OperatorWindowWithObservable(final Observable<U> other) {
     public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
         
         SourceSubscriber<T> sub = new SourceSubscriber<T>(child);
-        BoundarySubscriber<T, U> bs = new BoundarySubscriber<T, U>(child, sub);
+        BoundarySubscriber<T, U> bs = new BoundarySubscriber<T, U>(sub);
         
         child.add(sub);
         child.add(bs);
@@ -53,10 +57,6 @@ public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
         
         return sub;
     }
-    /** Indicate the current subject should complete and a new subject be emitted. */
-    static final Object NEXT_SUBJECT = new Object();
-    /** For error and completion indication. */
-    static final NotificationLite<Object> nl = NotificationLite.instance();
     /** Observes the source. */
     static final class SourceSubscriber<T> extends Subscriber<T> {
         final Subscriber<? super Observable<T>> child;
@@ -132,11 +132,11 @@ void drain(List<Object> queue) {
                 if (o == NEXT_SUBJECT) {
                     replaceSubject();
                 } else
-                if (nl.isError(o)) {
-                    error(nl.getError(o));
+                if (NL.isError(o)) {
+                    error(NL.getError(o));
                     break;
                 } else
-                if (nl.isCompleted(o)) {
+                if (NL.isCompleted(o)) {
                     complete();
                     break;
                 } else {
@@ -170,7 +170,7 @@ void emitValue(T t) {
         public void onError(Throwable e) {
             synchronized (guard) {
                 if (emitting) {
-                    queue = Collections.singletonList(nl.error(e));
+                    queue = Collections.singletonList(NL.error(e));
                     return;
                 }
                 queue = null;
@@ -187,7 +187,7 @@ public void onCompleted() {
                     if (queue == null) {
                         queue = new ArrayList<Object>();
                     }
-                    queue.add(nl.completed());
+                    queue.add(NL.completed());
                     return;
                 }
                 localQueue = queue;
@@ -269,7 +269,7 @@ void error(Throwable e) {
     /** Observes the boundary. */
     static final class BoundarySubscriber<T, U> extends Subscriber<U> {
         final SourceSubscriber<T> sub;
-        public BoundarySubscriber(Subscriber<?> child, SourceSubscriber<T> sub) {
+        public BoundarySubscriber(SourceSubscriber<T> sub) {
             this.sub = sub;
         }
         
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
index 9dbfed2bb7..80f6a95080 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
@@ -36,6 +36,11 @@
 public final class OperatorWindowWithObservableFactory<T, U> implements Operator<Observable<T>, T> {
     final Func0<? extends Observable<? extends U>> otherFactory;
 
+    /** Indicate the current subject should complete and a new subject be emitted. */
+    static final Object NEXT_SUBJECT = new Object();
+    /** For error and completion indication. */
+    static final NotificationLite<Object> NL = NotificationLite.instance();
+
     public OperatorWindowWithObservableFactory(Func0<? extends Observable<? extends U>> otherFactory) {
         this.otherFactory = otherFactory;
     }
@@ -51,10 +56,6 @@ public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
         
         return sub;
     }
-    /** Indicate the current subject should complete and a new subject be emitted. */
-    static final Object NEXT_SUBJECT = new Object();
-    /** For error and completion indication. */
-    static final NotificationLite<Object> nl = NotificationLite.instance();
     /** Observes the source. */
     static final class SourceSubscriber<T, U> extends Subscriber<T> {
         final Subscriber<? super Observable<T>> child;
@@ -138,11 +139,11 @@ void drain(List<Object> queue) {
                 if (o == NEXT_SUBJECT) {
                     replaceSubject();
                 } else
-                if (nl.isError(o)) {
-                    error(nl.getError(o));
+                if (NL.isError(o)) {
+                    error(NL.getError(o));
                     break;
                 } else
-                if (nl.isCompleted(o)) {
+                if (NL.isCompleted(o)) {
                     complete();
                     break;
                 } else {
@@ -173,7 +174,7 @@ void createNewWindow() {
                 return;
             }
             
-            BoundarySubscriber<T, U> bs = new BoundarySubscriber<T, U>(child, this);
+            BoundarySubscriber<T, U> bs = new BoundarySubscriber<T, U>(this);
             ssub.set(bs);
             other.unsafeSubscribe(bs);
         }
@@ -188,7 +189,7 @@ void emitValue(T t) {
         public void onError(Throwable e) {
             synchronized (guard) {
                 if (emitting) {
-                    queue = Collections.singletonList(nl.error(e));
+                    queue = Collections.singletonList(NL.error(e));
                     return;
                 }
                 queue = null;
@@ -205,7 +206,7 @@ public void onCompleted() {
                     if (queue == null) {
                         queue = new ArrayList<Object>();
                     }
-                    queue.add(nl.completed());
+                    queue.add(NL.completed());
                     return;
                 }
                 localQueue = queue;
@@ -288,7 +289,7 @@ void error(Throwable e) {
     static final class BoundarySubscriber<T, U> extends Subscriber<U> {
         final SourceSubscriber<T, U> sub;
         boolean done;
-        public BoundarySubscriber(Subscriber<?> child, SourceSubscriber<T, U> sub) {
+        public BoundarySubscriber(SourceSubscriber<T, U> sub) {
             this.sub = sub;
         }
         
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java b/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
index 28a6fffc21..bc6b601f34 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
@@ -196,7 +196,7 @@ public void onNext(V t) {
 
                 @Override
                 public void onError(Throwable e) {
-                    
+                    SourceSubscriber.this.onError(e);
                 }
 
                 @Override
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithTime.java b/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
index 8ea74a3e1a..beacce2cdf 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
@@ -46,6 +46,11 @@ public final class OperatorWindowWithTime<T> implements Operator<Observable<T>,
     final TimeUnit unit;
     final Scheduler scheduler;
     final int size;
+    /** Indicate the current subject should complete and a new subject be emitted. */
+    static final Object NEXT_SUBJECT = new Object();
+    /** For error and completion indication. */
+    static final NotificationLite<Object> NL = NotificationLite.instance();
+    
     
     public OperatorWindowWithTime(long timespan, long timeshift, TimeUnit unit, int size, Scheduler scheduler) {
         this.timespan = timespan;
@@ -73,11 +78,6 @@ public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
         s.scheduleChunk();
         return s;
     }
-    /** Indicate the current subject should complete and a new subject be emitted. */
-    static final Object NEXT_SUBJECT = new Object();
-    /** For error and completion indication. */
-    static final NotificationLite<Object> nl = NotificationLite.instance();
-    
     /** The immutable windowing state with one subject. */
     static final class State<T> {
         final Observer<T> consumer;
@@ -187,11 +187,11 @@ boolean drain(List<Object> queue) {
                         return false;
                     }
                 } else
-                if (nl.isError(o)) {
-                    error(nl.getError(o));
+                if (NL.isError(o)) {
+                    error(NL.getError(o));
                     break;
                 } else
-                if (nl.isCompleted(o)) {
+                if (NL.isCompleted(o)) {
                     complete();
                     break;
                 } else {
@@ -244,7 +244,7 @@ public void onError(Throwable e) {
             synchronized (guard) {
                 if (emitting) {
                     // drop any queued action and terminate asap
-                    queue = Collections.<Object>singletonList(nl.error(e));
+                    queue = Collections.<Object>singletonList(NL.error(e));
                     return;
                 }
                 queue = null;
@@ -278,7 +278,7 @@ public void onCompleted() {
                     if (queue == null) {
                         queue = new ArrayList<Object>();
                     }
-                    queue.add(nl.completed());
+                    queue.add(NL.completed());
                     return;
                 }
                 localQueue = queue;
diff --git a/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java b/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java
index 91c390e63d..8339eabf58 100644
--- a/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java
+++ b/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java
@@ -68,7 +68,6 @@ public void call(Subscriber<? super R> t) {
 
             
         for (int i = 0; i < n; i++) {
-            Observable<?> o = sources[i];
             if (serial.isUnsubscribed()) {
                 return;
             }
@@ -76,6 +75,7 @@ public void call(Subscriber<? super R> t) {
             WithLatestOtherSubscriber inner = new WithLatestOtherSubscriber(parent, i + 1);
             parent.add(inner);
             
+            Observable<?> o = sources[i];
             o.unsafeSubscribe(inner);
         }
         
diff --git a/src/main/java/rx/internal/operators/OperatorZip.java b/src/main/java/rx/internal/operators/OperatorZip.java
index 6f1280b3c3..805642e9a6 100644
--- a/src/main/java/rx/internal/operators/OperatorZip.java
+++ b/src/main/java/rx/internal/operators/OperatorZip.java
@@ -120,20 +120,20 @@ public Subscriber<? super Observable[]> call(final Subscriber<? super R> child)
     }
 
     @SuppressWarnings("rawtypes")
-    private final class ZipSubscriber extends Subscriber<Observable[]> {
+    final class ZipSubscriber extends Subscriber<Observable[]> {
 
         final Subscriber<? super R> child;
         final Zip<R> zipper;
         final ZipProducer<R> producer;
 
+        boolean started;
+
         public ZipSubscriber(Subscriber<? super R> child, Zip<R> zipper, ZipProducer<R> producer) {
             this.child = child;
             this.zipper = zipper;
             this.producer = producer;
         }
 
-        boolean started = false;
-
         @Override
         public void onCompleted() {
             if (!started) {
@@ -159,10 +159,11 @@ public void onNext(Observable[] observables) {
 
     }
 
-    private static final class ZipProducer<R> extends AtomicLong implements Producer {
+    static final class ZipProducer<R> extends AtomicLong implements Producer {
         /** */
         private static final long serialVersionUID = -1216676403723546796L;
-        private Zip<R> zipper;
+        
+        final Zip<R> zipper;
 
         public ZipProducer(Zip<R> zipper) {
             this.zipper = zipper;
@@ -186,7 +187,7 @@ static final class Zip<R> extends AtomicLong {
         private final CompositeSubscription childSubscription = new CompositeSubscription();
 
         static final int THRESHOLD = (int) (RxRingBuffer.SIZE * 0.7);
-        int emitted = 0; // not volatile/synchronized as accessed inside COUNTER_UPDATER block
+        int emitted; // not volatile/synchronized as accessed inside COUNTER_UPDATER block
 
         /* initialized when started in `start` */
         private volatile Object[] subscribers;
diff --git a/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java b/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
index 9d7319724c..d56a0693b8 100644
--- a/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
+++ b/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
@@ -46,7 +46,7 @@ public SingleOnSubscribeUsing(Func0<Resource> resourceFactory,
     
     @Override
     public void call(final SingleSubscriber<? super T> child) {
-        final Resource resource;
+        final Resource resource; // NOPMD 
         
         try {
             resource = resourceFactory.call();
diff --git a/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java b/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
index 393a72dfdd..3868c2d80d 100644
--- a/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
+++ b/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
@@ -21,7 +21,7 @@
 import rx.exceptions.Exceptions;
 import rx.functions.Func1;
 
-public class SingleOperatorOnErrorResumeNext<T> implements Single.OnSubscribe<T> {
+public final class SingleOperatorOnErrorResumeNext<T> implements Single.OnSubscribe<T> {
 
     private final Single<? extends T> originalSingle;
     private final Func1<Throwable, ? extends Single<? extends T>> resumeFunctionInCaseOfError;
diff --git a/src/main/java/rx/internal/operators/SingleOperatorZip.java b/src/main/java/rx/internal/operators/SingleOperatorZip.java
index 93afe523d3..7622ec600e 100644
--- a/src/main/java/rx/internal/operators/SingleOperatorZip.java
+++ b/src/main/java/rx/internal/operators/SingleOperatorZip.java
@@ -25,8 +25,13 @@
 import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
-public class SingleOperatorZip {
+public final class SingleOperatorZip {
 
+    /** Utility class. */
+    private SingleOperatorZip() {
+        throw new IllegalStateException("No instances!");
+    }
+    
     public static <T, R> Single<R> zip(final Single<? extends T>[] singles, final FuncN<? extends R> zipper) {
         return Single.create(new Single.OnSubscribe<R>() {
             @Override
diff --git a/src/main/java/rx/internal/producers/ProducerArbiter.java b/src/main/java/rx/internal/producers/ProducerArbiter.java
index b23904103e..ca4d220d1b 100644
--- a/src/main/java/rx/internal/producers/ProducerArbiter.java
+++ b/src/main/java/rx/internal/producers/ProducerArbiter.java
@@ -33,7 +33,7 @@ public final class ProducerArbiter implements Producer {
     static final Producer NULL_PRODUCER = new Producer() {
         @Override
         public void request(long n) {
-            
+            // deliberately ignored
         }
     };
      
diff --git a/src/main/java/rx/internal/producers/ProducerObserverArbiter.java b/src/main/java/rx/internal/producers/ProducerObserverArbiter.java
index 985352a3f4..46e86ba123 100644
--- a/src/main/java/rx/internal/producers/ProducerObserverArbiter.java
+++ b/src/main/java/rx/internal/producers/ProducerObserverArbiter.java
@@ -49,7 +49,7 @@ public final class ProducerObserverArbiter<T> implements Producer, Observer<T> {
     static final Producer NULL_PRODUCER = new Producer() {
         @Override
         public void request(long n) {
-            
+            // deliberately ignored
         }
     };
      
diff --git a/src/main/java/rx/internal/producers/SingleDelayedProducer.java b/src/main/java/rx/internal/producers/SingleDelayedProducer.java
index 12403fe21b..3b3f17bcd0 100644
--- a/src/main/java/rx/internal/producers/SingleDelayedProducer.java
+++ b/src/main/java/rx/internal/producers/SingleDelayedProducer.java
@@ -67,7 +67,7 @@ public void request(long n) {
                     emit(child, value);
                 }
             }
-            return;
+            return; // NOPMD 
         }
     }
      
@@ -85,7 +85,7 @@ public void setValue(T value) {
                     emit(child, value);
                 }
             }
-            return;
+            return; // NOPMD 
         }
     }
     /**
diff --git a/src/main/java/rx/internal/producers/SingleProducer.java b/src/main/java/rx/internal/producers/SingleProducer.java
index 337d815d91..51baf52547 100644
--- a/src/main/java/rx/internal/producers/SingleProducer.java
+++ b/src/main/java/rx/internal/producers/SingleProducer.java
@@ -55,11 +55,11 @@ public void request(long n) {
         if (compareAndSet(false, true)) {
             // avoid re-reading the instance fields
             final Subscriber<? super T> c = child;
-            T v = value;
             // eagerly check for unsubscription
             if (c.isUnsubscribed()) {
                 return;
             }
+            T v = value;
             // emit the value
             try {
                 c.onNext(v);
diff --git a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
index c1655f0aa3..2443400c48 100644
--- a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
+++ b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
@@ -28,12 +28,22 @@ public final class CachedThreadScheduler extends Scheduler implements SchedulerL
     private static final TimeUnit KEEP_ALIVE_UNIT = TimeUnit.SECONDS;
     
     static final ThreadWorker SHUTDOWN_THREADWORKER;
+
+    static final CachedWorkerPool NONE;
+
+    final ThreadFactory threadFactory;
+
+    final AtomicReference<CachedWorkerPool> pool;
+    
     static {
         SHUTDOWN_THREADWORKER = new ThreadWorker(RxThreadFactory.NONE);
         SHUTDOWN_THREADWORKER.unsubscribe();
+
+        NONE = new CachedWorkerPool(null, 0, null);
+        NONE.shutdown();
     }
     
-    private static final class CachedWorkerPool {
+    static final class CachedWorkerPool {
         private final ThreadFactory threadFactory;
         private final long keepAliveTime;
         private final ConcurrentLinkedQueue<ThreadWorker> expiringWorkerQueue;
@@ -131,15 +141,6 @@ void shutdown() {
         }
     }
 
-    final ThreadFactory threadFactory;
-    final AtomicReference<CachedWorkerPool> pool;
-    
-    static final CachedWorkerPool NONE;
-    static {
-        NONE = new CachedWorkerPool(null, 0, null);
-        NONE.shutdown();
-    }
-    
     public CachedThreadScheduler(ThreadFactory threadFactory) {
         this.threadFactory = threadFactory;
         this.pool = new AtomicReference<CachedWorkerPool>(NONE);
@@ -173,7 +174,7 @@ public Worker createWorker() {
         return new EventLoopWorker(pool.get());
     }
 
-    private static final class EventLoopWorker extends Scheduler.Worker {
+    static final class EventLoopWorker extends Scheduler.Worker {
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
         private final CachedWorkerPool pool;
         private final ThreadWorker threadWorker;
@@ -226,7 +227,7 @@ public void call() {
         }
     }
 
-    private static final class ThreadWorker extends NewThreadWorker {
+    static final class ThreadWorker extends NewThreadWorker {
         private long expirationTime;
 
         ThreadWorker(ThreadFactory threadFactory) {
diff --git a/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java b/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
index fb813412db..4caf2e3218 100644
--- a/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
+++ b/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
@@ -48,7 +48,14 @@ public final class EventLoopsScheduler extends Scheduler implements SchedulerLif
         SHUTDOWN_WORKER = new PoolWorker(RxThreadFactory.NONE);
         SHUTDOWN_WORKER.unsubscribe();
     }
+
+    /** This will indicate no pool is active. */
+    static final FixedSchedulerPool NONE = new FixedSchedulerPool(null, 0);
+
+    final ThreadFactory threadFactory;
     
+    final AtomicReference<FixedSchedulerPool> pool;
+
     static final class FixedSchedulerPool {
         final int cores;
 
@@ -79,11 +86,6 @@ public void shutdown() {
             }
         }
     }
-    /** This will indicate no pool is active. */
-    static final FixedSchedulerPool NONE = new FixedSchedulerPool(null, 0);
-
-    final ThreadFactory threadFactory;
-    final AtomicReference<FixedSchedulerPool> pool;
     
     /**
      * Create a scheduler with pool size equal to the available processor
@@ -134,7 +136,7 @@ public Subscription scheduleDirect(Action0 action) {
        return pw.scheduleActual(action, -1, TimeUnit.NANOSECONDS);
     }
 
-    private static class EventLoopWorker extends Scheduler.Worker {
+    static final class EventLoopWorker extends Scheduler.Worker {
         private final SubscriptionList serial = new SubscriptionList();
         private final CompositeSubscription timed = new CompositeSubscription();
         private final SubscriptionList both = new SubscriptionList(serial, timed);
diff --git a/src/main/java/rx/internal/schedulers/ImmediateScheduler.java b/src/main/java/rx/internal/schedulers/ImmediateScheduler.java
index c3dd7a6f85..7b0b2df045 100644
--- a/src/main/java/rx/internal/schedulers/ImmediateScheduler.java
+++ b/src/main/java/rx/internal/schedulers/ImmediateScheduler.java
@@ -30,6 +30,7 @@ public final class ImmediateScheduler extends Scheduler {
     public static final ImmediateScheduler INSTANCE = new ImmediateScheduler();
 
     private ImmediateScheduler() {
+        // the class is singleton
     }
 
     @Override
@@ -41,9 +42,6 @@ private class InnerImmediateScheduler extends Scheduler.Worker implements Subscr
 
         final BooleanSubscription innerSubscription = new BooleanSubscription();
 
-        InnerImmediateScheduler() {
-        }
-
         @Override
         public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
             // since we are executing immediately on this thread we must cause this thread to sleep
diff --git a/src/main/java/rx/internal/schedulers/NewThreadWorker.java b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
index 6521aadf46..25517124be 100644
--- a/src/main/java/rx/internal/schedulers/NewThreadWorker.java
+++ b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
@@ -15,7 +15,7 @@
  */
 package rx.internal.schedulers;
 
-import java.lang.reflect.Method;
+import java.lang.reflect.*;
 import java.util.Iterator;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicReference;
@@ -45,6 +45,17 @@ public class NewThreadWorker extends Scheduler.Worker implements Subscription {
     public static final int PURGE_FREQUENCY;
     private static final ConcurrentHashMap<ScheduledThreadPoolExecutor, ScheduledThreadPoolExecutor> EXECUTORS;
     private static final AtomicReference<ScheduledExecutorService> PURGE;
+    /**
+     * Improves performance of {@link #tryEnableCancelPolicy(ScheduledExecutorService)}.
+     * Also, it works even for inheritance: {@link Method} of base class can be invoked on the instance of child class.
+     */
+    private static volatile Object cachedSetRemoveOnCancelPolicyMethod;
+
+    /**
+     * Possible value of {@link #cachedSetRemoveOnCancelPolicyMethod} which means that cancel policy is not supported.
+     */
+    private static final Object SET_REMOVE_ON_CANCEL_POLICY_METHOD_NOT_SUPPORTED = new Object();
+    
     static {
         EXECUTORS = new ConcurrentHashMap<ScheduledThreadPoolExecutor, ScheduledThreadPoolExecutor>();
         PURGE = new AtomicReference<ScheduledExecutorService>();
@@ -115,17 +126,6 @@ static void purgeExecutors() {
         }
     }
 
-    /**
-     * Improves performance of {@link #tryEnableCancelPolicy(ScheduledExecutorService)}.
-     * Also, it works even for inheritance: {@link Method} of base class can be invoked on the instance of child class.
-     */
-    private static volatile Object cachedSetRemoveOnCancelPolicyMethod;
-
-    /**
-     * Possible value of {@link #cachedSetRemoveOnCancelPolicyMethod} which means that cancel policy is not supported.
-     */
-     private static final Object SET_REMOVE_ON_CANCEL_POLICY_METHOD_NOT_SUPPORTED = new Object();
-
     /**
      * Tries to enable the Java 7+ setRemoveOnCancelPolicy.
      * <p>{@code public} visibility reason: called from other package(s) within RxJava.
@@ -135,10 +135,10 @@ static void purgeExecutors() {
      * @return true if the policy was successfully enabled 
      */
     public static boolean tryEnableCancelPolicy(ScheduledExecutorService executor) {
-        if (SHOULD_TRY_ENABLE_CANCEL_POLICY) {
+        if (SHOULD_TRY_ENABLE_CANCEL_POLICY) { // NOPMD 
             final boolean isInstanceOfScheduledThreadPoolExecutor = executor instanceof ScheduledThreadPoolExecutor;
 
-            final Method methodToCall;
+            Method methodToCall;
 
             if (isInstanceOfScheduledThreadPoolExecutor) {
                 final Object localSetRemoveOnCancelPolicyMethod = cachedSetRemoveOnCancelPolicyMethod;
@@ -166,7 +166,11 @@ public static boolean tryEnableCancelPolicy(ScheduledExecutorService executor) {
                 try {
                     methodToCall.invoke(executor, true);
                     return true;
-                } catch (Exception e) {
+                } catch (InvocationTargetException e) {
+                    RxJavaHooks.onError(e);
+                } catch (IllegalAccessException e) {
+                    RxJavaHooks.onError(e);
+                } catch (IllegalArgumentException e) {
                     RxJavaHooks.onError(e);
                 }
             }
diff --git a/src/main/java/rx/internal/schedulers/ScheduledAction.java b/src/main/java/rx/internal/schedulers/ScheduledAction.java
index 6ba16beaee..51db03e250 100644
--- a/src/main/java/rx/internal/schedulers/ScheduledAction.java
+++ b/src/main/java/rx/internal/schedulers/ScheduledAction.java
@@ -53,21 +53,20 @@ public void run() {
         try {
             lazySet(Thread.currentThread());
             action.call();
+        } catch (OnErrorNotImplementedException e) {
+            signalError(new IllegalStateException("Exception thrown on Scheduler.Worker thread. Add `onError` handling.", e));
         } catch (Throwable e) {
-            // nothing to do but print a System error as this is fatal and there is nowhere else to throw this
-            IllegalStateException ie = null;
-            if (e instanceof OnErrorNotImplementedException) {
-                ie = new IllegalStateException("Exception thrown on Scheduler.Worker thread. Add `onError` handling.", e);
-            } else {
-                ie = new IllegalStateException("Fatal Exception thrown on Scheduler.Worker thread.", e);
-            }
-            RxJavaHooks.onError(ie);
-            Thread thread = Thread.currentThread();
-            thread.getUncaughtExceptionHandler().uncaughtException(thread, ie);
+            signalError(new IllegalStateException("Fatal Exception thrown on Scheduler.Worker thread.", e));
         } finally {
             unsubscribe();
         }
     }
+    
+    void signalError(Throwable ie) {
+        RxJavaHooks.onError(ie);
+        Thread thread = Thread.currentThread();
+        thread.getUncaughtExceptionHandler().uncaughtException(thread, ie);
+    }
 
     @Override
     public boolean isUnsubscribed() {
@@ -128,7 +127,7 @@ public void addParent(SubscriptionList parent) {
      * prevent unnecessary self-interrupting if the unsubscription
      * happens from the same thread.
      */
-    private final class FutureCompleter implements Subscription {
+    final class FutureCompleter implements Subscription {
         private final Future<?> f;
 
         FutureCompleter(Future<?> f) {
@@ -150,7 +149,7 @@ public boolean isUnsubscribed() {
     }
 
     /** Remove a child subscription from a composite when unsubscribing. */
-    private static final class Remover extends AtomicBoolean implements Subscription {
+    static final class Remover extends AtomicBoolean implements Subscription {
         /** */
         private static final long serialVersionUID = 247232374289553518L;
         final ScheduledAction s;
@@ -175,7 +174,7 @@ public void unsubscribe() {
 
     }
     /** Remove a child subscription from a composite when unsubscribing. */
-    private static final class Remover2 extends AtomicBoolean implements Subscription {
+    static final class Remover2 extends AtomicBoolean implements Subscription {
         /** */
         private static final long serialVersionUID = 247232374289553518L;
         final ScheduledAction s;
diff --git a/src/main/java/rx/internal/schedulers/SleepingAction.java b/src/main/java/rx/internal/schedulers/SleepingAction.java
index e3bdeb16ba..ef39676e0f 100644
--- a/src/main/java/rx/internal/schedulers/SleepingAction.java
+++ b/src/main/java/rx/internal/schedulers/SleepingAction.java
@@ -16,6 +16,7 @@
 package rx.internal.schedulers;
 
 import rx.Scheduler;
+import rx.exceptions.Exceptions;
 import rx.functions.Action0;
 
 /* package */class SleepingAction implements Action0 {
@@ -41,7 +42,7 @@ public void call() {
                 Thread.sleep(delay);
             } catch (InterruptedException e) {
                 Thread.currentThread().interrupt();
-                throw new RuntimeException(e);
+                Exceptions.propagate(e);
             }
         }
 
diff --git a/src/main/java/rx/internal/schedulers/TrampolineScheduler.java b/src/main/java/rx/internal/schedulers/TrampolineScheduler.java
index 94fea1964a..fb03dcb58d 100644
--- a/src/main/java/rx/internal/schedulers/TrampolineScheduler.java
+++ b/src/main/java/rx/internal/schedulers/TrampolineScheduler.java
@@ -40,16 +40,13 @@ public Worker createWorker() {
     private TrampolineScheduler() {
     }
 
-    private static class InnerCurrentThreadScheduler extends Scheduler.Worker implements Subscription {
+    static final class InnerCurrentThreadScheduler extends Scheduler.Worker implements Subscription {
 
         final AtomicInteger counter = new AtomicInteger();
         final PriorityBlockingQueue<TimedAction> queue = new PriorityBlockingQueue<TimedAction>();
         private final BooleanSubscription innerSubscription = new BooleanSubscription();
         private final AtomicInteger wip = new AtomicInteger();
 
-        InnerCurrentThreadScheduler() {
-        }
-
         @Override
         public Subscription schedule(Action0 action) {
             return enqueue(action, now());
@@ -102,7 +99,7 @@ public boolean isUnsubscribed() {
 
     }
 
-    private static final class TimedAction implements Comparable<TimedAction> {
+    static final class TimedAction implements Comparable<TimedAction> {
         final Action0 action;
         final Long execTime;
         final int count; // In case if time between enqueueing took less than 1ms
diff --git a/src/main/java/rx/internal/util/BackpressureDrainManager.java b/src/main/java/rx/internal/util/BackpressureDrainManager.java
index 08bb3beb58..b2f9555fbc 100644
--- a/src/main/java/rx/internal/util/BackpressureDrainManager.java
+++ b/src/main/java/rx/internal/util/BackpressureDrainManager.java
@@ -31,6 +31,15 @@
 public final class BackpressureDrainManager extends AtomicLong implements Producer {
     /** */
     private static final long serialVersionUID = 2826241102729529449L;
+    /** Indicates if one is in emitting phase, guarded by this. */
+    boolean emitting;
+    /** Indicates a terminal state. */
+    volatile boolean terminated;
+    /** Indicates an error state, barrier is provided via terminated. */
+    Throwable exception;
+    /** The callbacks to manage the drain. */
+    final BackpressureQueueCallback actual;
+
     /**
      * Interface representing the minimal callbacks required
      * to operate the drain part of a backpressure system.
@@ -65,14 +74,6 @@ public interface BackpressureQueueCallback {
         void complete(Throwable exception);
     }
 
-    /** Indicates if one is in emitting phase, guarded by this. */
-    protected boolean emitting;
-    /** Indicates a terminal state. */
-    protected volatile boolean terminated;
-    /** Indicates an error state, barrier is provided via terminated. */
-    protected Throwable exception;
-    /** The callbacks to manage the drain. */
-    protected final BackpressureQueueCallback actual;
     /**
      * Constructs a backpressure drain manager with 0 requestedCount,
      * no terminal event and not emitting.
@@ -85,14 +86,14 @@ public BackpressureDrainManager(BackpressureQueueCallback actual) {
      * Checks if a terminal state has been reached.
      * @return true if a terminal state has been reached
      */
-    public final boolean isTerminated() {
+    public boolean isTerminated() {
         return terminated;
     }
     /**
      * Move into a terminal state. 
      * Call drain() anytime after.
      */
-    public final void terminate() {
+    public void terminate() {
         terminated = true;
     }
     /**
@@ -102,7 +103,7 @@ public final void terminate() {
      * element emission.
      * @param error the exception to deliver
      */
-    public final void terminate(Throwable error) {
+    public void terminate(Throwable error) {
         if (!terminated) {
             exception = error;
             terminated = true;
@@ -111,7 +112,7 @@ public final void terminate(Throwable error) {
     /**
      * Move into a terminal state and drain. 
      */
-    public final void terminateAndDrain() {
+    public void terminateAndDrain() {
         terminated = true;
         drain();
     }
@@ -121,7 +122,7 @@ public final void terminateAndDrain() {
      * element emission.
      * @param error the exception to deliver
      */
-    public final void terminateAndDrain(Throwable error) {
+    public void terminateAndDrain(Throwable error) {
         if (!terminated) {
             exception = error;
             terminated = true;
@@ -129,7 +130,7 @@ public final void terminateAndDrain(Throwable error) {
         }
     }
     @Override
-    public final void request(long n) {
+    public void request(long n) {
         if (n == 0) {
             return;
         }
@@ -163,8 +164,7 @@ public final void request(long n) {
      * Try to drain the "queued" elements and terminal events
      * by considering the available and requested event counts.
      */
-    public final void drain() {
-        long n;
+    public void drain() {
         boolean term;
         synchronized (this) {
             if (emitting) {
@@ -173,7 +173,7 @@ public final void drain() {
             emitting = true;
             term = terminated;
         }
-        n = get();
+        long n = get();
         boolean skipFinal = false;
         try {
             BackpressureQueueCallback a = actual;
diff --git a/src/main/java/rx/internal/util/BlockingUtils.java b/src/main/java/rx/internal/util/BlockingUtils.java
index 951e49c83d..17b0143e52 100644
--- a/src/main/java/rx/internal/util/BlockingUtils.java
+++ b/src/main/java/rx/internal/util/BlockingUtils.java
@@ -53,7 +53,7 @@ public static void awaitForComplete(CountDownLatch latch, Subscription subscript
             // for more information see https://github.com/ReactiveX/RxJava/pull/147#issuecomment-13624780
             Thread.currentThread().interrupt();
             // using Runtime so it is not checked
-            throw new RuntimeException("Interrupted while waiting for subscription to complete.", e);
+            throw new IllegalStateException("Interrupted while waiting for subscription to complete.", e);
         }
     }
 }
diff --git a/src/main/java/rx/internal/util/FrontPadding.java b/src/main/java/rx/internal/util/FrontPadding.java
deleted file mode 100644
index 972315440d..0000000000
--- a/src/main/java/rx/internal/util/FrontPadding.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- *
- * 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 rx.internal.util;
-
-import java.io.Serializable;
-
-/**
- * Padding up to 128 bytes at the front.
- * Based on netty's implementation
- */
-abstract class FrontPadding implements Serializable {
-    /** */
-    private static final long serialVersionUID = -596356687591714352L;
-    /** Padding. */
-    public transient long p1, p2, p3, p4, p5, p6;           // 48 bytes (header is 16 bytes)
-    /** Padding. */
-    public transient long p8, p9, p10, p11, p12, p13, p14, p15; // 64 bytes
-}
\ No newline at end of file
diff --git a/src/main/java/rx/internal/util/IndexedRingBuffer.java b/src/main/java/rx/internal/util/IndexedRingBuffer.java
index d434662866..d5fc2f2e0b 100644
--- a/src/main/java/rx/internal/util/IndexedRingBuffer.java
+++ b/src/main/java/rx/internal/util/IndexedRingBuffer.java
@@ -47,6 +47,10 @@
  * @param <E>
  */
 public final class IndexedRingBuffer<E> implements Subscription {
+    private final ElementSection<E> elements = new ElementSection<E>();
+    private final IndexSection removed = new IndexSection();
+    /* package for unit testing */final AtomicInteger index = new AtomicInteger();
+    /* package for unit testing */final AtomicInteger removedIndex = new AtomicInteger();
 
     private static final ObjectPool<IndexedRingBuffer<?>> POOL = new ObjectPool<IndexedRingBuffer<?>>() {
 
@@ -57,16 +61,10 @@ protected IndexedRingBuffer<?> createObject() {
 
     };
 
-    @SuppressWarnings("unchecked")
-    public static <T> IndexedRingBuffer<T> getInstance() {
-        return (IndexedRingBuffer<T>) POOL.borrowObject();
-    }
+    static int defaultSize = 256;
+
+    /* package for unit testing */static final int SIZE;
 
-    private final ElementSection<E> elements = new ElementSection<E>();
-    private final IndexSection removed = new IndexSection();
-    /* package for unit testing */final AtomicInteger index = new AtomicInteger();
-    /* package for unit testing */final AtomicInteger removedIndex = new AtomicInteger();
-    
     // default size of ring buffer
     /**
      * Set at 256 ... Android defaults far smaller which likely will never hit the use cases that require the higher buffers.
@@ -238,25 +236,29 @@ public static <T> IndexedRingBuffer<T> getInstance() {
      * 
      * } </pre>
      */
-    static int _size = 256;
     static {
         // lower default for Android (https://github.com/ReactiveX/RxJava/issues/1820)
         if (PlatformDependent.isAndroid()) {
-            _size = 8;
+            defaultSize = 8;
         }
 
         // possible system property for overriding
         String sizeFromProperty = System.getProperty("rx.indexed-ring-buffer.size"); // also see RxRingBuffer
         if (sizeFromProperty != null) {
             try {
-                _size = Integer.parseInt(sizeFromProperty);
-            } catch (Exception e) {
-                System.err.println("Failed to set 'rx.indexed-ring-buffer.size' with value " + sizeFromProperty + " => " + e.getMessage());
+                defaultSize = Integer.parseInt(sizeFromProperty);
+            } catch (NumberFormatException e) {
+                System.err.println("Failed to set 'rx.indexed-ring-buffer.size' with value " + sizeFromProperty + " => " + e.getMessage()); // NOPMD 
             }
         }
+        
+        SIZE = defaultSize;
     }
     
-    /* package for unit testing */static final int SIZE = _size;
+    @SuppressWarnings("unchecked")
+    public static <T> IndexedRingBuffer<T> getInstance() {
+        return (IndexedRingBuffer<T>) POOL.borrowObject();
+    }
 
     /**
      * This resets the arrays, nulls out references and returns it to the pool.
@@ -291,6 +293,7 @@ public void unsubscribe() {
     }
 
     IndexedRingBuffer() {
+        // nothing to do
     }
 
     /**
@@ -355,7 +358,7 @@ private ElementSection<E> getElementSection(int index) {
         return a;
     }
 
-    private synchronized int getIndexForAdd() {
+    private synchronized int getIndexForAdd() { // NOPMD 
         /*
          * Synchronized as I haven't yet figured out a way to do this in an atomic way that doesn't involve object allocation
          */
@@ -384,7 +387,7 @@ private synchronized int getIndexForAdd() {
      * 
      * @return
      */
-    private synchronized int getIndexFromPreviouslyRemoved() {
+    private synchronized int getIndexFromPreviouslyRemoved() { // NOPMD 
         /*
          * Synchronized as I haven't yet figured out a way to do this in an atomic way that doesn't involve object allocation
          */
@@ -404,7 +407,7 @@ private synchronized int getIndexFromPreviouslyRemoved() {
         }
     }
 
-    private synchronized void pushRemovedIndex(int elementIndex) {
+    private synchronized void pushRemovedIndex(int elementIndex) { // NOPMD 
         /*
          * Synchronized as I haven't yet figured out a way to do this in an atomic way that doesn't involve object allocation
          */
@@ -483,13 +486,10 @@ private int forEach(Func1<? super E, Boolean> action, int startIndex, int endInd
         return realIndex;
     }
 
-    private static class ElementSection<E> {
+    static final class ElementSection<E> {
         final AtomicReferenceArray<E> array = new AtomicReferenceArray<E>(SIZE);
         final AtomicReference<ElementSection<E>> next = new AtomicReference<ElementSection<E>>();
 
-        ElementSection() {
-        }
-
         ElementSection<E> getNext() {
             if (next.get() != null) {
                 return next.get();
@@ -506,12 +506,11 @@ ElementSection<E> getNext() {
         }
     }
 
-    private static class IndexSection {
+    static class IndexSection {
 
         private final AtomicIntegerArray unsafeArray = new AtomicIntegerArray(SIZE);
 
-        IndexSection() {
-        }
+        private final AtomicReference<IndexSection> _next = new AtomicReference<IndexSection>();
 
         public int getAndSet(int expected, int newValue) {
             return unsafeArray.getAndSet(expected, newValue);
@@ -521,8 +520,6 @@ public void set(int i, int elementIndex) {
             unsafeArray.set(i, elementIndex);
         }
 
-        private final AtomicReference<IndexSection> _next = new AtomicReference<IndexSection>();
-
         IndexSection getNext() {
             if (_next.get() != null) {
                 return _next.get();
diff --git a/src/main/java/rx/internal/util/InternalObservableUtils.java b/src/main/java/rx/internal/util/InternalObservableUtils.java
index 0a72b2fd6d..5b4478fd2c 100644
--- a/src/main/java/rx/internal/util/InternalObservableUtils.java
+++ b/src/main/java/rx/internal/util/InternalObservableUtils.java
@@ -32,12 +32,36 @@
  */
 public enum InternalObservableUtils {
     ;
+    /**
+     * A BiFunction that expects a long as its first parameter and returns +1.
+     */
+    public static final PlusOneLongFunc2 LONG_COUNTER = new PlusOneLongFunc2();
+
+    /**
+     * A bifunction comparing two objects via null-safe equals.
+     */
+    public static final ObjectEqualsFunc2 OBJECT_EQUALS = new ObjectEqualsFunc2();
+    /**
+     * A function that converts a List of Observables into an array of Observables.
+     */
+    public static final ToArrayFunc1 TO_ARRAY = new ToArrayFunc1();
     
+    static final ReturnsVoidFunc1 RETURNS_VOID = new ReturnsVoidFunc1();
+
     /**
      * A BiFunction that expects an integer as its first parameter and returns +1.
      */
     public static final PlusOneFunc2 COUNTER = new PlusOneFunc2();
 
+    static final NotificationErrorExtractor ERROR_EXTRACTOR = new NotificationErrorExtractor();
+
+    /**
+     * Throws an OnErrorNotImplementedException when called.
+     */
+    public static final Action1<Throwable> ERROR_NOT_IMPLEMENTED = new ErrorNotImplementedAction();
+
+    public static final Operator<Boolean, Object> IS_EMPTY = new OperatorAny<Object>(UtilityFunctions.alwaysTrue(), true);
+
     static final class PlusOneFunc2 implements Func2<Integer, Object, Integer> {
         @Override
         public Integer call(Integer count, Object o) {
@@ -45,11 +69,6 @@ public Integer call(Integer count, Object o) {
         }
     }
     
-    /**
-     * A BiFunction that expects a long as its first parameter and returns +1.
-     */
-    public static final PlusOneLongFunc2 LONG_COUNTER = new PlusOneLongFunc2();
-    
     static final class PlusOneLongFunc2 implements Func2<Long, Object, Long> {
         @Override
         public Long call(Long count, Object o) {
@@ -57,11 +76,6 @@ public Long call(Long count, Object o) {
         }
     }
 
-    /**
-     * A bifunction comparing two objects via null-safe equals.
-     */
-    public static final ObjectEqualsFunc2 OBJECT_EQUALS = new ObjectEqualsFunc2();
-
     static final class ObjectEqualsFunc2 implements Func2<Object, Object, Boolean> {
         @Override
         public Boolean call(Object first, Object second) {
@@ -69,11 +83,6 @@ public Boolean call(Object first, Object second) {
         }
     }
 
-    /**
-     * A function that converts a List of Observables into an array of Observables.
-     */
-    public static final ToArrayFunc1 TO_ARRAY = new ToArrayFunc1();
-    
     static final class ToArrayFunc1 implements Func1<List<? extends Observable<?>>, Observable<?>[]> {
         @Override
         public Observable<?>[] call(List<? extends Observable<?>> o) {
@@ -151,8 +160,6 @@ public Observable<?> call(Observable<? extends Notification<?>> notifications) {
         }
     };
     
-    static final ReturnsVoidFunc1 RETURNS_VOID = new ReturnsVoidFunc1();
-    
     static final class ReturnsVoidFunc1 implements Func1<Object, Void> {
         @Override
         public Void call(Object t) {
@@ -217,8 +224,6 @@ public Observable<?> call(Observable<? extends Notification<?>> notifications) {
         }
     }
     
-    static final NotificationErrorExtractor ERROR_EXTRACTOR = new NotificationErrorExtractor();
-    
     static final class NotificationErrorExtractor implements Func1<Notification<?>, Throwable> {
         @Override
         public Throwable call(Notification<?> t) {
@@ -236,7 +241,7 @@ public static <T> Func0<ConnectableObservable<T>> createReplaySupplier(final Obs
         return new ReplaySupplierNoParams<T>(source);
     }
 
-    private static final class ReplaySupplierNoParams<T> implements Func0<ConnectableObservable<T>> {
+    static final class ReplaySupplierNoParams<T> implements Func0<ConnectableObservable<T>> {
         private final Observable<T> source;
 
         private ReplaySupplierNoParams(Observable<T> source) {
@@ -375,11 +380,6 @@ public R call(R state, T value) {
         }
     }
 
-    /**
-     * Throws an OnErrorNotImplementedException when called.
-     */
-    public static final Action1<Throwable> ERROR_NOT_IMPLEMENTED = new ErrorNotImplementedAction();
-    
     static final class ErrorNotImplementedAction implements Action1<Throwable> {
         @Override
         public void call(Throwable t) {
@@ -387,5 +387,4 @@ public void call(Throwable t) {
         }
     }
     
-    public static final Operator<Boolean, Object> IS_EMPTY = new OperatorAny<Object>(UtilityFunctions.alwaysTrue(), true);
 }
diff --git a/src/main/java/rx/internal/util/LinkedArrayList.java b/src/main/java/rx/internal/util/LinkedArrayList.java
index fb4ae68cc2..35f5254eeb 100644
--- a/src/main/java/rx/internal/util/LinkedArrayList.java
+++ b/src/main/java/rx/internal/util/LinkedArrayList.java
@@ -80,14 +80,14 @@ public void add(Object o) {
      * @return the head object array
      */
     public Object[] head() {
-        return head;
+        return head; // NOPMD 
     }
     /**
      * Returns the tail buffer segment or null if the list is empty.
      * @return the tail object array
      */
     public Object[] tail() {
-        return tail;
+        return tail; // NOPMD 
     }
     /**
      * Returns the total size of the list.
diff --git a/src/main/java/rx/internal/util/ObjectPool.java b/src/main/java/rx/internal/util/ObjectPool.java
index 35da79335a..7b22a3e122 100644
--- a/src/main/java/rx/internal/util/ObjectPool.java
+++ b/src/main/java/rx/internal/util/ObjectPool.java
@@ -33,7 +33,7 @@ public abstract class ObjectPool<T> implements SchedulerLifecycle {
     private final AtomicReference<Future<?>> periodicTask;
 
     public ObjectPool() {
-        this(0, 0, 67);
+        this(0, 0, 67); // NOPMD 
     }
 
     /**
diff --git a/src/main/java/rx/internal/util/OpenHashSet.java b/src/main/java/rx/internal/util/OpenHashSet.java
index 1e79fdd4c1..7115b43519 100644
--- a/src/main/java/rx/internal/util/OpenHashSet.java
+++ b/src/main/java/rx/internal/util/OpenHashSet.java
@@ -40,6 +40,7 @@ public final class OpenHashSet<T> {
     int size;
     int maxSize;
     T[] keys;
+    private static final int INT_PHI = 0x9E3779B9;
     
     public OpenHashSet() {
         this(16, 0.75f);
@@ -172,7 +173,7 @@ void rehash() {
         
         
         for (int j = size; j-- != 0; ) {
-            while (a[--i] == null);
+            while (a[--i] == null); // NOPMD 
             int pos = mix(a[i].hashCode()) & m;
             if (b[pos] != null) {
                 for (;;) {
@@ -190,8 +191,6 @@ void rehash() {
         this.keys = b;
     }
     
-    private static final int INT_PHI = 0x9E3779B9;
-    
     static int mix(int x) {
         final int h = x * INT_PHI;
         return h ^ (h >>> 16);
@@ -206,6 +205,6 @@ public boolean isEmpty() {
      * @return the raw array of values of this set
      */
     public T[] values() {
-        return keys;
+        return keys; // NOPMD 
     }
 }
diff --git a/src/main/java/rx/internal/util/PlatformDependent.java b/src/main/java/rx/internal/util/PlatformDependent.java
index 2aa5f7e184..e1a28c8a08 100644
--- a/src/main/java/rx/internal/util/PlatformDependent.java
+++ b/src/main/java/rx/internal/util/PlatformDependent.java
@@ -34,6 +34,11 @@ public final class PlatformDependent {
 
     private static final boolean IS_ANDROID = ANDROID_API_VERSION != ANDROID_API_VERSION_IS_NOT_ANDROID;
 
+    /** Utility class. */
+    private PlatformDependent() {
+        throw new IllegalStateException("No instances!");
+    }
+    
     /**
      * Returns {@code true} if and only if the current platform is Android.
      * @return {@code true} if and only if the current platform is Android
@@ -65,7 +70,7 @@ private static int resolveAndroidApiVersion() {
                     .forName("android.os.Build$VERSION", true, getSystemClassLoader())
                     .getField("SDK_INT")
                     .get(null);
-        } catch (Exception e) {
+        } catch (Exception e) { // NOPMD 
             // Can not resolve version of Android API, maybe current platform is not Android
             // or API of resolving current Version of Android API has changed in some release of Android
             return ANDROID_API_VERSION_IS_NOT_ANDROID;
diff --git a/src/main/java/rx/internal/util/RxJavaPluginUtils.java b/src/main/java/rx/internal/util/RxJavaPluginUtils.java
index 4e459130e5..e54eb1fd69 100644
--- a/src/main/java/rx/internal/util/RxJavaPluginUtils.java
+++ b/src/main/java/rx/internal/util/RxJavaPluginUtils.java
@@ -19,6 +19,11 @@
 
 public final class RxJavaPluginUtils {
 
+    /** Utility class. */
+    private RxJavaPluginUtils() {
+        throw new IllegalStateException("No instances!");
+    }
+    
     public static void handleException(Throwable e) {
         try {
             RxJavaHooks.onError(e);
@@ -33,8 +38,8 @@ private static void handlePluginException(Throwable pluginException) {
          * Since the plugin should never throw this is a safety net
          * and will complain loudly to System.err so it gets fixed.
          */
-        System.err.println("RxJavaErrorHandler threw an Exception. It shouldn't. => " + pluginException.getMessage());
-        pluginException.printStackTrace();
+        System.err.println("RxJavaErrorHandler threw an Exception. It shouldn't. => " + pluginException.getMessage()); // NOPMD 
+        pluginException.printStackTrace(); // NOPMD 
     }
     
 }
diff --git a/src/main/java/rx/internal/util/RxRingBuffer.java b/src/main/java/rx/internal/util/RxRingBuffer.java
index 5f35c7f6e5..b2104f811d 100644
--- a/src/main/java/rx/internal/util/RxRingBuffer.java
+++ b/src/main/java/rx/internal/util/RxRingBuffer.java
@@ -32,22 +32,6 @@
  */
 public class RxRingBuffer implements Subscription {
 
-    public static RxRingBuffer getSpscInstance() {
-        if (UnsafeAccess.isUnsafeAvailable()) {
-            return new RxRingBuffer(SPSC_POOL, SIZE);
-        } else {
-            return new RxRingBuffer();
-        }
-    }
-
-    public static RxRingBuffer getSpmcInstance() {
-        if (UnsafeAccess.isUnsafeAvailable()) {
-            return new RxRingBuffer(SPMC_POOL, SIZE);
-        } else {
-            return new RxRingBuffer();
-        }
-    }
-
     /**
      * Queue implementation testing that led to current choices of data structures:
      * 
@@ -141,7 +125,7 @@ public static RxRingBuffer getSpmcInstance() {
      * } </pre>
      */
 
-    private static final NotificationLite<Object> on = NotificationLite.instance();
+    private static final NotificationLite<Object> ON = NotificationLite.instance();
 
     private Queue<Object> queue;
 
@@ -257,27 +241,27 @@ public static RxRingBuffer getSpmcInstance() {
      * r.o.OperatorObserveOnPerf.observeOnNewThread     1000000  thrpt         5        1.173        0.100    ops/s
      * } </pre>
      */
-    static int _size = 128;
+    static int defaultSize = 128;
     static {
         // lower default for Android (https://github.com/ReactiveX/RxJava/issues/1820)
         if (PlatformDependent.isAndroid()) {
-            _size = 16;
+            defaultSize = 16;
         }
 
         // possible system property for overriding
         String sizeFromProperty = System.getProperty("rx.ring-buffer.size"); // also see IndexedRingBuffer
         if (sizeFromProperty != null) {
             try {
-                _size = Integer.parseInt(sizeFromProperty);
-            } catch (Exception e) {
-                System.err.println("Failed to set 'rx.buffer.size' with value " + sizeFromProperty + " => " + e.getMessage());
+                defaultSize = Integer.parseInt(sizeFromProperty);
+            } catch (NumberFormatException e) {
+                System.err.println("Failed to set 'rx.buffer.size' with value " + sizeFromProperty + " => " + e.getMessage()); // NOPMD 
             }
         }
     }
-    public static final int SIZE = _size;
+    public static final int SIZE = defaultSize;
 
     /* Public so Schedulers can manage the lifecycle of the inner worker. */
-    public static ObjectPool<Queue<Object>> SPSC_POOL = new ObjectPool<Queue<Object>>() {
+    public static final ObjectPool<Queue<Object>> SPSC_POOL = new ObjectPool<Queue<Object>>() {
 
         @Override
         protected SpscArrayQueue<Object> createObject() {
@@ -287,7 +271,7 @@ protected SpscArrayQueue<Object> createObject() {
     };
 
     /* Public so Schedulers can manage the lifecycle of the inner worker. */
-    public static ObjectPool<Queue<Object>> SPMC_POOL = new ObjectPool<Queue<Object>>() {
+    public static final ObjectPool<Queue<Object>> SPMC_POOL = new ObjectPool<Queue<Object>>() {
 
         @Override
         protected SpmcArrayQueue<Object> createObject() {
@@ -295,7 +279,23 @@ protected SpmcArrayQueue<Object> createObject() {
         }
 
     };
-    
+
+    public static RxRingBuffer getSpscInstance() {
+        if (UnsafeAccess.isUnsafeAvailable()) {
+            return new RxRingBuffer(SPSC_POOL, SIZE);
+        } else {
+            return new RxRingBuffer();
+        }
+    }
+
+    public static RxRingBuffer getSpmcInstance() {
+        if (UnsafeAccess.isUnsafeAvailable()) {
+            return new RxRingBuffer(SPMC_POOL, SIZE);
+        } else {
+            return new RxRingBuffer();
+        }
+    }
+
     private RxRingBuffer(Queue<Object> queue, int size) {
         this.queue = queue;
         this.pool = null;
@@ -308,7 +308,7 @@ private RxRingBuffer(ObjectPool<Queue<Object>> pool, int size) {
         this.size = size;
     }
 
-    public synchronized void release() {
+    public synchronized void release() { // NOPMD 
         Queue<Object> q = queue;
         ObjectPool<Queue<Object>> p = pool;
         if (p != null && q != null) {
@@ -339,7 +339,7 @@ public void onNext(Object o) throws MissingBackpressureException {
         synchronized (this) {
             Queue<Object> q = queue;
             if (q != null) {
-                mbe = !q.offer(on.next(o));
+                mbe = !q.offer(ON.next(o));
             } else {
                 iae = true;
             }
@@ -356,14 +356,14 @@ public void onNext(Object o) throws MissingBackpressureException {
     public void onCompleted() {
         // we ignore terminal events if we already have one
         if (terminalState == null) {
-            terminalState = on.completed();
+            terminalState = ON.completed();
         }
     }
 
     public void onError(Throwable t) {
         // we ignore terminal events if we already have one
         if (terminalState == null) {
-            terminalState = on.error(t);
+            terminalState = ON.error(t);
         }
     }
 
@@ -429,24 +429,24 @@ public Object peek() {
     }
 
     public boolean isCompleted(Object o) {
-        return on.isCompleted(o);
+        return ON.isCompleted(o);
     }
 
     public boolean isError(Object o) {
-        return on.isError(o);
+        return ON.isError(o);
     }
 
     public Object getValue(Object o) {
-        return on.getValue(o);
+        return ON.getValue(o);
     }
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public boolean accept(Object o, Observer child) {
-        return on.accept(child, o);
+        return ON.accept(child, o);
     }
 
     public Throwable asError(Object o) {
-        return on.getError(o);
+        return ON.getError(o);
     }
 
     @Override
diff --git a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
index 8c56935596..af2f102021 100644
--- a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
+++ b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
@@ -34,6 +34,9 @@
  * @param <T> the value type
  */
 public final class ScalarSynchronousObservable<T> extends Observable<T> {
+    /** The constant scalar value to emit on request. */
+    final T t;
+
     /**
      * Indicates that the Producer used by this Observable should be fully
      * threadsafe. It is possible, but unlikely that multiple concurrent
@@ -69,9 +72,6 @@ public static <T> ScalarSynchronousObservable<T> create(T t) {
         return new ScalarSynchronousObservable<T>(t);
     }
 
-    /** The constant scalar value to emit on request. */
-    final T t;
-
     protected ScalarSynchronousObservable(final T t) {
         super(RxJavaHooks.onCreate(new JustOnSubscribe<T>(t)));
         this.t = t;
@@ -93,7 +93,7 @@ public T get() {
      * @return the new observable
      */
     public Observable<T> scalarScheduleOn(final Scheduler scheduler) {
-        final Func1<Action0, Subscription> onSchedule;
+        Func1<Action0, Subscription> onSchedule;
         if (scheduler instanceof EventLoopsScheduler) {
             final EventLoopsScheduler els = (EventLoopsScheduler) scheduler;
             onSchedule = new Func1<Action0, Subscription>() {
diff --git a/src/main/java/rx/internal/util/ScalarSynchronousSingle.java b/src/main/java/rx/internal/util/ScalarSynchronousSingle.java
index 83b7d456a1..2a0844ca28 100644
--- a/src/main/java/rx/internal/util/ScalarSynchronousSingle.java
+++ b/src/main/java/rx/internal/util/ScalarSynchronousSingle.java
@@ -26,12 +26,12 @@
 
 public final class ScalarSynchronousSingle<T> extends Single<T> {
 
-    public static final <T> ScalarSynchronousSingle<T> create(T t) {
+    final T value;
+
+    public static <T> ScalarSynchronousSingle<T> create(T t) {
         return new ScalarSynchronousSingle<T>(t);
     }
 
-    final T value;
-
     protected ScalarSynchronousSingle(final T t) {
         super(new OnSubscribe<T>() {
 
@@ -136,6 +136,7 @@ public void call(final SingleSubscriber<? super R> child) {
                     Subscriber<R> subscriber = new Subscriber<R>() {
                         @Override
                         public void onCompleted() {
+                            // deliberately ignored
                         }
 
                         @Override
diff --git a/src/main/java/rx/internal/util/SubscriptionList.java b/src/main/java/rx/internal/util/SubscriptionList.java
index 6f6f391dde..c5dc85d388 100644
--- a/src/main/java/rx/internal/util/SubscriptionList.java
+++ b/src/main/java/rx/internal/util/SubscriptionList.java
@@ -27,16 +27,28 @@
  */
 public final class SubscriptionList implements Subscription {
 
-    private LinkedList<Subscription> subscriptions;
+    private List<Subscription> subscriptions;
     private volatile boolean unsubscribed;
 
+    /**
+     * Constructs an empty SubscriptionList.
+     */
     public SubscriptionList() {
+        // nothing to do
     }
 
+    /**
+     * Constructs a SubscriptionList with the given initial child subscriptions.
+     * @param subscriptions the array of subscriptions to start with
+     */
     public SubscriptionList(final Subscription... subscriptions) {
         this.subscriptions = new LinkedList<Subscription>(Arrays.asList(subscriptions));
     }
 
+    /**
+     * Constructs a SubscriptionList with the given initial child subscription.
+     * @param s the initial subscription instance
+     */
     public SubscriptionList(Subscription s) {
         this.subscriptions = new LinkedList<Subscription>();
         this.subscriptions.add(s);
@@ -62,7 +74,7 @@ public void add(final Subscription s) {
         if (!unsubscribed) {
             synchronized (this) {
                 if (!unsubscribed) {
-                    LinkedList<Subscription> subs = subscriptions;
+                    List<Subscription> subs = subscriptions;
                     if (subs == null) {
                         subs = new LinkedList<Subscription>();
                         subscriptions = subs;
@@ -80,7 +92,7 @@ public void remove(final Subscription s) {
         if (!unsubscribed) {
             boolean unsubscribe = false;
             synchronized (this) {
-                LinkedList<Subscription> subs = subscriptions;
+                List<Subscription> subs = subscriptions;
                 if (unsubscribed || subs == null) {
                     return;
                 }
diff --git a/src/main/java/rx/internal/util/SynchronizedQueue.java b/src/main/java/rx/internal/util/SynchronizedQueue.java
index 8f0c4a7372..5b0795aef6 100644
--- a/src/main/java/rx/internal/util/SynchronizedQueue.java
+++ b/src/main/java/rx/internal/util/SynchronizedQueue.java
@@ -25,9 +25,9 @@
  *
  * @param <T>
  */
-public class SynchronizedQueue<T> implements Queue<T> {
+public class SynchronizedQueue<T> implements Queue<T>, Cloneable {
 
-    private final LinkedList<T> list = new LinkedList<T>();
+    private final Queue<T> list = new LinkedList<T>();
     private final int size;
 
     public SynchronizedQueue() {
@@ -39,62 +39,62 @@ public SynchronizedQueue(int size) {
     }
 
     @Override
-    public synchronized boolean isEmpty() {
+    public synchronized boolean isEmpty() { // NOPMD 
         return list.isEmpty();
     }
 
     @Override
-    public synchronized boolean contains(Object o) {
+    public synchronized boolean contains(Object o) { // NOPMD 
         return list.contains(o);
     }
 
     @Override
-    public synchronized Iterator<T> iterator() {
+    public synchronized Iterator<T> iterator() { // NOPMD 
         return list.iterator();
     }
 
     @Override
-    public synchronized int size() {
+    public synchronized int size() { // NOPMD 
         return list.size();
     }
 
     @Override
-    public synchronized boolean add(T e) {
+    public synchronized boolean add(T e) { // NOPMD 
         return list.add(e);
     }
 
     @Override
-    public synchronized boolean remove(Object o) {
+    public synchronized boolean remove(Object o) { // NOPMD 
         return list.remove(o);
     }
 
     @Override
-    public synchronized boolean containsAll(Collection<?> c) {
+    public synchronized boolean containsAll(Collection<?> c) { // NOPMD 
         return list.containsAll(c);
     }
 
     @Override
-    public synchronized boolean addAll(Collection<? extends T> c) {
+    public synchronized boolean addAll(Collection<? extends T> c) { // NOPMD 
         return list.addAll(c);
     }
 
     @Override
-    public synchronized boolean removeAll(Collection<?> c) {
+    public synchronized boolean removeAll(Collection<?> c) { // NOPMD 
         return list.removeAll(c);
     }
 
     @Override
-    public synchronized boolean retainAll(Collection<?> c) {
+    public synchronized boolean retainAll(Collection<?> c) { // NOPMD 
         return list.retainAll(c);
     }
 
     @Override
-    public synchronized void clear() {
+    public synchronized void clear() { // NOPMD 
         list.clear();
     }
 
     @Override
-    public synchronized String toString() {
+    public synchronized String toString() { // NOPMD 
         return list.toString();
     }
 
@@ -105,43 +105,48 @@ public int hashCode() {
 
     @Override
     public boolean equals(Object obj) {
-        if (this == obj)
+        if (this == obj) {
             return true;
-        if (obj == null)
+        }
+        if (obj == null) {
             return false;
-        if (getClass() != obj.getClass())
+        }
+        if (getClass() != obj.getClass()) {
             return false;
+        }
         SynchronizedQueue<?> other = (SynchronizedQueue<?>) obj;
         if (list == null) {
-            if (other.list != null)
+            if (other.list != null) {
                 return false;
-        } else if (!list.equals(other.list))
+            }
+        } else if (!list.equals(other.list)) {
             return false;
+        }
         return true;
     }
 
     @Override
-    public synchronized T peek() {
+    public synchronized T peek() { // NOPMD 
         return list.peek();
     }
 
     @Override
-    public synchronized T element() {
+    public synchronized T element() { // NOPMD 
         return list.element();
     }
 
     @Override
-    public synchronized T poll() {
+    public synchronized T poll() { // NOPMD 
         return list.poll();
     }
 
     @Override
-    public synchronized T remove() {
+    public synchronized T remove() { // NOPMD 
         return list.remove();
     }
 
     @Override
-    public synchronized boolean offer(T e) {
+    public synchronized boolean offer(T e) { // NOPMD 
         if (size > -1 && list.size() + 1 > size) {
             return false;
         }
@@ -149,19 +154,19 @@ public synchronized boolean offer(T e) {
     }
 
     @Override
-    public synchronized Object clone() {
+    public synchronized Object clone() { // NOPMD 
         SynchronizedQueue<T> q = new SynchronizedQueue<T>(size);
         q.addAll(list);
         return q;
     }
 
     @Override
-    public synchronized Object[] toArray() {
+    public synchronized Object[] toArray() { // NOPMD 
         return list.toArray();
     }
 
     @Override
-    public synchronized <R> R[] toArray(R[] a) {
+    public synchronized <R> R[] toArray(R[] a) { // NOPMD 
         return list.toArray(a);
     }
 
diff --git a/src/main/java/rx/internal/util/SynchronizedSubscription.java b/src/main/java/rx/internal/util/SynchronizedSubscription.java
deleted file mode 100644
index d8c1c9944f..0000000000
--- a/src/main/java/rx/internal/util/SynchronizedSubscription.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- * 
- * 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 rx.internal.util;
-
-import rx.Subscription;
-
-public class SynchronizedSubscription implements Subscription {
-
-    private final Subscription s;
-
-    public SynchronizedSubscription(Subscription s) {
-        this.s = s;
-    }
-
-    @Override
-    public synchronized void unsubscribe() {
-        s.unsubscribe();
-    }
-
-    @Override
-    public synchronized boolean isUnsubscribed() {
-        return s.isUnsubscribed();
-    }
-
-}
diff --git a/src/main/java/rx/internal/util/UtilityFunctions.java b/src/main/java/rx/internal/util/UtilityFunctions.java
index 5fe24cb75a..adf2c2c011 100644
--- a/src/main/java/rx/internal/util/UtilityFunctions.java
+++ b/src/main/java/rx/internal/util/UtilityFunctions.java
@@ -28,7 +28,14 @@
  * Utility functions for internal use that we don't want part of the public API. 
  */
 public final class UtilityFunctions {
+    @SuppressWarnings("rawtypes")
+    private static final NullFunction NULL_FUNCTION = new NullFunction();
 
+    /** Utility class. */
+    private UtilityFunctions() {
+        throw new IllegalStateException("No instances!");
+    }
+    
     /**
      * Returns a function that always returns {@code true}.
      *
@@ -103,10 +110,7 @@ public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> NullFunction<T0, T1, T
         return NULL_FUNCTION;
     }
 
-    @SuppressWarnings("rawtypes")
-    private static final NullFunction NULL_FUNCTION = new NullFunction();
-
-    private static final class NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> implements
+    static final class NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> implements
             Func0<R>,
             Func1<T0, R>,
             Func2<T0, T1, R>,
@@ -118,8 +122,6 @@ private static final class NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
             Func8<T0, T1, T2, T3, T4, T5, T6, T7, R>,
             Func9<T0, T1, T2, T3, T4, T5, T6, T7, T8, R>,
             FuncN<R> {
-        NullFunction() {
-        }
 
         @Override
         public R call() {
diff --git a/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java b/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java
index f7594ba20a..33d45b011b 100644
--- a/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java
@@ -36,8 +36,7 @@ public Iterator<E> iterator() {
     @Override
     public void clear() {
         // we have to test isEmpty because of the weaker poll() guarantee
-        while (poll() != null || !isEmpty())
-            ;
+        while (poll() != null || !isEmpty()) ; // NOPMD 
     }
     protected final int calcElementOffset(long index, int mask) {
         return (int)index & mask;
diff --git a/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java b/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
index 3775f550bf..e9bc346d32 100644
--- a/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
+++ b/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
@@ -70,7 +70,7 @@ public final int size() {
         // must chase the nodes all the way to the producer node, but there's no need to chase a moving target.
         while (chaserNode != producerNode && size < Integer.MAX_VALUE) {
             LinkedQueueNode<E> next;
-            while((next = chaserNode.lvNext()) == null);
+            while((next = chaserNode.lvNext()) == null); // NOPMD 
             chaserNode = next;
             size++;
         }
diff --git a/src/main/java/rx/internal/util/atomic/LinkedQueueNode.java b/src/main/java/rx/internal/util/atomic/LinkedQueueNode.java
index d687460c64..719f04e828 100644
--- a/src/main/java/rx/internal/util/atomic/LinkedQueueNode.java
+++ b/src/main/java/rx/internal/util/atomic/LinkedQueueNode.java
@@ -24,7 +24,9 @@ public final class LinkedQueueNode<E> extends AtomicReference<LinkedQueueNode<E>
     private E value;
     
     public LinkedQueueNode() {
+        // no initial value
     }
+    
     public LinkedQueueNode(E val) {
         spValue(val);
     }
diff --git a/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java b/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
index 31f54bd5ce..b4ef15f91b 100644
--- a/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
+++ b/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
@@ -55,7 +55,7 @@ public MpscLinkedAtomicQueue() {
      * @see java.util.Queue#offer(java.lang.Object)
      */
     @Override
-    public final boolean offer(final E nextValue) {
+    public boolean offer(final E nextValue) {
         if (nextValue == null) {
             throw new NullPointerException("null elements not allowed");
         }
@@ -83,7 +83,7 @@ public final boolean offer(final E nextValue) {
      * @see java.util.Queue#poll()
      */
     @Override
-    public final E poll() {
+    public E poll() {
         LinkedQueueNode<E> currConsumerNode = lpConsumerNode(); // don't load twice, it's alright
         LinkedQueueNode<E> nextNode = currConsumerNode.lvNext();
         if (nextNode != null) {
@@ -94,7 +94,7 @@ public final E poll() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null);
+            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD 
             // got the next node...
             
             // we have to null out the value because we are going to hang on to the node
@@ -106,7 +106,7 @@ else if (currConsumerNode != lvProducerNode()) {
     }
 
     @Override
-    public final E peek() {
+    public E peek() {
         LinkedQueueNode<E> currConsumerNode = lpConsumerNode(); // don't load twice, it's alright
         LinkedQueueNode<E> nextNode = currConsumerNode.lvNext();
         if (nextNode != null) {
@@ -114,7 +114,7 @@ public final E peek() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null);
+            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD 
             // got the next node...
             return nextNode.lpValue();
         }
diff --git a/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
index 6240a5f156..03ec839c07 100644
--- a/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
@@ -35,7 +35,7 @@
 public final class SpscAtomicArrayQueue<E> extends AtomicReferenceArrayQueue<E> {
     private static final Integer MAX_LOOK_AHEAD_STEP = Integer.getInteger("jctools.spsc.max.lookahead.step", 4096);
     final AtomicLong producerIndex;
-    protected long producerLookAhead;
+    long producerLookAhead;
     final AtomicLong consumerIndex;
     final int lookAheadStep;
     public SpscAtomicArrayQueue(int capacity) {
diff --git a/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
index 53f9b719ce..e0d41b21a0 100644
--- a/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
@@ -82,7 +82,7 @@ public T peek() {
     }
     @Override
     public void clear() {
-        while (poll() != null || !isEmpty());
+        while (poll() != null || !isEmpty()); // NOPMD 
     }
     @Override
     public boolean isEmpty() {
diff --git a/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
index 4e4943dfcb..a37326f09d 100644
--- a/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
@@ -35,14 +35,15 @@
  */
 public final class SpscLinkedArrayQueue<T> implements Queue<T> {
     static final int MAX_LOOK_AHEAD_STEP = Integer.getInteger("jctools.spsc.max.lookahead.step", 4096);
-    protected final AtomicLong producerIndex;
-    protected int producerLookAheadStep;
-    protected long producerLookAhead;
-    protected int producerMask;
-    protected AtomicReferenceArray<Object> producerBuffer;
-    protected int consumerMask;
-    protected AtomicReferenceArray<Object> consumerBuffer;
-    protected final AtomicLong consumerIndex;
+    final AtomicLong producerIndex;
+    int producerLookAheadStep;
+    long producerLookAhead;
+    int producerMask;
+    AtomicReferenceArray<Object> producerBuffer;
+    int consumerMask;
+    AtomicReferenceArray<Object> consumerBuffer;
+    final AtomicLong consumerIndex;
+    
     private static final Object HAS_NEXT = new Object();
 
     public SpscLinkedArrayQueue(final int bufferSize) {
@@ -65,7 +66,7 @@ public SpscLinkedArrayQueue(final int bufferSize) {
      * This implementation is correct for single producer thread use only.
      */
     @Override
-    public final boolean offer(final T e) {
+    public boolean offer(final T e) {
         // local load of field to avoid repeated loads after volatile reads
         final AtomicReferenceArray<Object> buffer = producerBuffer;
         final long index = lpProducerIndex();
@@ -122,7 +123,7 @@ private AtomicReferenceArray<Object> lvNext(AtomicReferenceArray<Object> curr) {
      */
     @SuppressWarnings("unchecked")
     @Override
-    public final T poll() {
+    public T poll() {
         // local load of field to avoid repeated loads after volatile reads
         final AtomicReferenceArray<Object> buffer = consumerBuffer;
         final long index = lpConsumerIndex();
@@ -162,7 +163,7 @@ private T newBufferPoll(AtomicReferenceArray<Object> nextBuffer, final long inde
      */
     @SuppressWarnings("unchecked")
     @Override
-    public final T peek() {
+    public T peek() {
         final AtomicReferenceArray<Object> buffer = consumerBuffer;
         final long index = lpConsumerIndex();
         final int mask = consumerMask;
@@ -177,7 +178,7 @@ public final T peek() {
     
     @Override
     public void clear() {
-        while (poll() != null || !isEmpty());
+        while (poll() != null || !isEmpty()); // NOPMD 
     }
 
     @SuppressWarnings("unchecked")
@@ -188,7 +189,7 @@ private T newBufferPeek(AtomicReferenceArray<Object> nextBuffer, final long inde
     }
 
     @Override
-    public final int size() {
+    public int size() {
         /*
          * It is possible for a thread to be interrupted or reschedule between the read of the producer and
          * consumer indices, therefore protection is required to ensure size is within valid range. In the
@@ -254,7 +255,7 @@ private static <E> Object lvElement(AtomicReferenceArray<Object> buffer, int off
     }
 
     @Override
-    public final Iterator<T> iterator() {
+    public Iterator<T> iterator() {
         throw new UnsupportedOperationException();
     }
 
diff --git a/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
index 728591794e..017b0a8245 100644
--- a/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
@@ -33,12 +33,12 @@
 public final class SpscUnboundedAtomicArrayQueue<T> implements Queue<T> {
     static final int MAX_LOOK_AHEAD_STEP = Integer.getInteger("jctools.spsc.max.lookahead.step", 4096);
     final AtomicLong producerIndex;
-    protected int producerLookAheadStep;
-    protected long producerLookAhead;
-    protected int producerMask;
-    protected AtomicReferenceArray<Object> producerBuffer;
-    protected int consumerMask;
-    protected AtomicReferenceArray<Object> consumerBuffer;
+    int producerLookAheadStep;
+    long producerLookAhead;
+    int producerMask;
+    AtomicReferenceArray<Object> producerBuffer;
+    int consumerMask;
+    AtomicReferenceArray<Object> consumerBuffer;
     final AtomicLong consumerIndex;
     private static final Object HAS_NEXT = new Object();
 
@@ -63,7 +63,7 @@ public SpscUnboundedAtomicArrayQueue(final int bufferSize) {
      * This implementation is correct for single producer thread use only.
      */
     @Override
-    public final boolean offer(final T e) {
+    public boolean offer(final T e) {
         if (e == null) {
             throw new NullPointerException();
         }
@@ -123,7 +123,7 @@ private AtomicReferenceArray<Object> lvNext(AtomicReferenceArray<Object> curr) {
      */
     @SuppressWarnings("unchecked")
     @Override
-    public final T poll() {
+    public T poll() {
         // local load of field to avoid repeated loads after volatile reads
         final AtomicReferenceArray<Object> buffer = consumerBuffer;
         final long index = lpConsumerIndex();
@@ -163,7 +163,7 @@ private T newBufferPoll(AtomicReferenceArray<Object> nextBuffer, final long inde
      */
     @SuppressWarnings("unchecked")
     @Override
-    public final T peek() {
+    public T peek() {
         final AtomicReferenceArray<Object> buffer = consumerBuffer;
         final long index = lpConsumerIndex();
         final int mask = consumerMask;
@@ -178,7 +178,7 @@ public final T peek() {
     
     @Override
     public void clear() {
-        while (poll() != null || !isEmpty());
+        while (poll() != null || !isEmpty()); // NOPMD 
     }
 
     @SuppressWarnings("unchecked")
@@ -189,7 +189,7 @@ private T newBufferPeek(AtomicReferenceArray<Object> nextBuffer, final long inde
     }
 
     @Override
-    public final int size() {
+    public int size() {
         /*
          * It is possible for a thread to be interrupted or reschedule between the read of the producer and
          * consumer indices, therefore protection is required to ensure size is within valid range. In the
@@ -255,7 +255,7 @@ private static <E> Object lvElement(AtomicReferenceArray<Object> buffer, int off
     }
 
     @Override
-    public final Iterator<T> iterator() {
+    public Iterator<T> iterator() {
         throw new UnsupportedOperationException();
     }
 
diff --git a/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java b/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
index 05bcb798fb..8a5c600421 100644
--- a/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
@@ -102,7 +102,7 @@ public final int size() {
         // must chase the nodes all the way to the producer node, but there's no need to chase a moving target.
         while (chaserNode != producerNode && size < Integer.MAX_VALUE) {
             LinkedQueueNode<E> next;
-            while((next = chaserNode.lvNext()) == null);
+            while((next = chaserNode.lvNext()) == null); // NOPMD 
             chaserNode = next;
             size++;
         }
diff --git a/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java b/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
index a8b9990b56..06e90da3ea 100644
--- a/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
@@ -180,7 +180,6 @@ public Iterator<E> iterator() {
     @Override
     public void clear() {
         // we have to test isEmpty because of the weaker poll() guarantee
-        while (poll() != null || !isEmpty())
-            ;
+        while (poll() != null || !isEmpty()) ; // NOPMD 
     }
 }
diff --git a/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java b/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
index 2607c3a023..11e034e85c 100644
--- a/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
@@ -42,7 +42,7 @@ public MpscLinkedQueue() {
     }
     
     @SuppressWarnings("unchecked")
-    protected final LinkedQueueNode<E> xchgProducerNode(LinkedQueueNode<E> newVal) {
+    protected LinkedQueueNode<E> xchgProducerNode(LinkedQueueNode<E> newVal) {
         Object oldVal;
         do {
             oldVal = producerNode;
@@ -67,7 +67,7 @@ protected final LinkedQueueNode<E> xchgProducerNode(LinkedQueueNode<E> newVal) {
      * @see java.util.Queue#offer(java.lang.Object)
      */
     @Override
-    public final boolean offer(final E nextValue) {
+    public boolean offer(final E nextValue) {
         if (nextValue == null) {
             throw new NullPointerException("null elements not allowed");
         }
@@ -96,7 +96,7 @@ public final boolean offer(final E nextValue) {
      * @see java.util.Queue#poll()
      */
     @Override
-    public final E poll() {
+    public E poll() {
         LinkedQueueNode<E> currConsumerNode = lpConsumerNode(); // don't load twice, it's alright
         LinkedQueueNode<E> nextNode = currConsumerNode.lvNext();
         if (nextNode != null) {
@@ -107,7 +107,7 @@ public final E poll() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null);
+            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD 
             // got the next node...
             
             // we have to null out the value because we are going to hang on to the node
@@ -119,7 +119,7 @@ else if (currConsumerNode != lvProducerNode()) {
     }
 
     @Override
-    public final E peek() {
+    public E peek() {
         LinkedQueueNode<E> currConsumerNode = consumerNode; // don't load twice, it's alright
         LinkedQueueNode<E> nextNode = currConsumerNode.lvNext();
         if (nextNode != null) {
@@ -127,7 +127,7 @@ public final E peek() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null);
+            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD 
             // got the next node...
             return nextNode.lpValue();
         }
diff --git a/src/main/java/rx/internal/util/unsafe/QueueProgressIndicators.java b/src/main/java/rx/internal/util/unsafe/QueueProgressIndicators.java
index 185f0bd612..f75152e161 100644
--- a/src/main/java/rx/internal/util/unsafe/QueueProgressIndicators.java
+++ b/src/main/java/rx/internal/util/unsafe/QueueProgressIndicators.java
@@ -37,7 +37,7 @@ public interface QueueProgressIndicators {
      * 
      * @return the current value of the producer progress index
      */
-    public long currentProducerIndex();
+    long currentProducerIndex();
 
     /**
      * This method has no concurrent visibility semantics. The value returned may be negative. Under normal
@@ -50,5 +50,5 @@ public interface QueueProgressIndicators {
      * 
      * @return the current value of the consumer progress index
      */
-    public long currentConsumerIndex();
+    long currentConsumerIndex();
 }
\ No newline at end of file
diff --git a/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
index 8a4251872d..cdd029ade1 100644
--- a/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
@@ -129,7 +129,7 @@ public boolean offer(final E e) {
             }
             else {
                 // spin wait for slot to clear, buggers wait freedom
-                while(null != lvElement(lb, offset));
+                while(null != lvElement(lb, offset)); // NOPMD 
             }
         }
         spElement(lb, offset, e);
diff --git a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
index 6175bab455..dc353e0ae7 100644
--- a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
@@ -69,13 +69,17 @@ public class SpscUnboundedArrayQueue<E> extends SpscUnboundedArrayQueueConsumerF
             Field iField = SpscUnboundedArrayQueueProducerFields.class.getDeclaredField("producerIndex");
             P_INDEX_OFFSET = UNSAFE.objectFieldOffset(iField);
         } catch (NoSuchFieldException e) {
-            throw new RuntimeException(e);
+            InternalError ex = new InternalError();
+            ex.initCause(e);
+            throw ex;
         }
         try {
             Field iField = SpscUnboundedArrayQueueConsumerField.class.getDeclaredField("consumerIndex");
             C_INDEX_OFFSET = UNSAFE.objectFieldOffset(iField);
         } catch (NoSuchFieldException e) {
-            throw new RuntimeException(e);
+            InternalError ex = new InternalError();
+            ex.initCause(e);
+            throw ex;
         }
     }
 
diff --git a/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java b/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
index 076112982f..fd3fd447a2 100644
--- a/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
+++ b/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
@@ -27,14 +27,15 @@
  * {@code rx.unsafe-disable}.
  */
 public final class UnsafeAccess {
-    private UnsafeAccess() {
-        throw new IllegalStateException("No instances!");
-    }
 
     public static final Unsafe UNSAFE;
 
     private static final boolean DISABLED_BY_USER = System.getProperty("rx.unsafe-disable") != null;
 
+    private UnsafeAccess() {
+        throw new IllegalStateException("No instances!");
+    }
+
     static {
         Unsafe u = null;
         try {
@@ -47,7 +48,7 @@ private UnsafeAccess() {
             Field field = Unsafe.class.getDeclaredField("theUnsafe");
             field.setAccessible(true);
             u = (Unsafe) field.get(null);
-        } catch (Throwable e) {
+        } catch (Throwable e) { // NOPMD 
             // do nothing, hasUnsafe() will return false
         }
         UNSAFE = u;
@@ -65,8 +66,9 @@ public static int getAndIncrementInt(Object obj, long offset) {
         for (;;) {
             int current = UNSAFE.getIntVolatile(obj, offset);
             int next = current + 1;
-            if (UNSAFE.compareAndSwapInt(obj, offset, current, next))
+            if (UNSAFE.compareAndSwapInt(obj, offset, current, next)) {
                 return current;
+            }
         }
     }
 
@@ -74,16 +76,18 @@ public static int getAndAddInt(Object obj, long offset, int n) {
         for (;;) {
             int current = UNSAFE.getIntVolatile(obj, offset);
             int next = current + n;
-            if (UNSAFE.compareAndSwapInt(obj, offset, current, next))
+            if (UNSAFE.compareAndSwapInt(obj, offset, current, next)) {
                 return current;
+            }
         }
     }
 
     public static int getAndSetInt(Object obj, long offset, int newValue) {
         for (;;) {
             int current = UNSAFE.getIntVolatile(obj, offset);
-            if (UNSAFE.compareAndSwapInt(obj, offset, current, newValue))
+            if (UNSAFE.compareAndSwapInt(obj, offset, current, newValue)) {
                 return current;
+            }
         }
     }
 
diff --git a/src/main/java/rx/observables/AsyncOnSubscribe.java b/src/main/java/rx/observables/AsyncOnSubscribe.java
index a32175fd9c..d1394d7547 100644
--- a/src/main/java/rx/observables/AsyncOnSubscribe.java
+++ b/src/main/java/rx/observables/AsyncOnSubscribe.java
@@ -94,7 +94,7 @@ public abstract class AsyncOnSubscribe<S, T> implements OnSubscribe<T> {
      *            {@link #next(Object, long, Observer)} or unsubscribing.
      */
     protected void onUnsubscribe(S state) {
-
+        // default behavior is no-op
     }
 
     /**
@@ -269,7 +269,7 @@ public void call(Void t) {
      * @param <T>
      *            the type of compatible Subscribers
      */
-    private static final class AsyncOnSubscribeImpl<S, T> extends AsyncOnSubscribe<S, T> {
+    static final class AsyncOnSubscribeImpl<S, T> extends AsyncOnSubscribe<S, T> {
         private final Func0<? extends S> generator;
         private final Func3<? super S, Long, ? super Observer<Observable<? extends T>>, ? extends S> next;
         private final Action1<? super S> onUnsubscribe;
@@ -304,8 +304,9 @@ protected S next(S state, long requested, Observer<Observable<? extends T>> obse
 
         @Override
         protected void onUnsubscribe(S state) {
-            if (onUnsubscribe != null)
+            if (onUnsubscribe != null) {
                 onUnsubscribe.call(state);
+            }
         }
     }
 
@@ -586,8 +587,9 @@ public void onNext(final Observable<? extends T> t) {
                 throw new IllegalStateException("onNext called multiple times!");
             }
             onNextCalled = true;
-            if (hasTerminated)
+            if (hasTerminated) {
                 return;
+            }
             subscribeBufferToObservable(t);
         }
 
@@ -631,12 +633,12 @@ public void call() {
     }
 
     static final class UnicastSubject<T> extends Observable<T>implements Observer<T> {
+        private final State<T> state;
+
         public static <T> UnicastSubject<T> create() {
             return new UnicastSubject<T>(new State<T>());
         }
 
-        private State<T> state;
-
         protected UnicastSubject(final State<T> state) {
             super(state);
             this.state = state;
diff --git a/src/main/java/rx/observables/BlockingObservable.java b/src/main/java/rx/observables/BlockingObservable.java
index 53991409af..e9db68f358 100644
--- a/src/main/java/rx/observables/BlockingObservable.java
+++ b/src/main/java/rx/observables/BlockingObservable.java
@@ -23,7 +23,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.annotations.Experimental;
-import rx.exceptions.OnErrorNotImplementedException;
+import rx.exceptions.*;
 import rx.functions.*;
 import rx.internal.operators.*;
 import rx.internal.util.BlockingUtils;
@@ -53,6 +53,15 @@ public final class BlockingObservable<T> {
 
     private final Observable<? extends T> o;
 
+    /** Constant to indicate the onStart method should be called. */
+    static final Object ON_START = new Object();
+
+    /** Constant indicating the setProducer method should be called. */
+    static final Object SET_PRODUCER = new Object();
+
+    /** Indicates an unsubscription happened */
+    static final Object UNSUBSCRIBE = new Object();
+
     private BlockingObservable(Observable<? extends T> o) {
         this.o = o;
     }
@@ -129,11 +138,7 @@ public void onNext(T args) {
         BlockingUtils.awaitForComplete(latch, subscription);
 
         if (exceptionFromOnError.get() != null) {
-            if (exceptionFromOnError.get() instanceof RuntimeException) {
-                throw (RuntimeException) exceptionFromOnError.get();
-            } else {
-                throw new RuntimeException(exceptionFromOnError.get());
-            }
+            Exceptions.propagate(exceptionFromOnError.get());
         }
     }
 
@@ -457,11 +462,7 @@ public void onNext(final T item) {
         BlockingUtils.awaitForComplete(latch, subscription);
 
         if (returnException.get() != null) {
-            if (returnException.get() instanceof RuntimeException) {
-                throw (RuntimeException) returnException.get();
-            } else {
-                throw new RuntimeException(returnException.get());
-            }
+            Exceptions.propagate(returnException.get());
         }
 
         return returnItem.get();
@@ -478,7 +479,7 @@ public void subscribe() {
         Subscription s = ((Observable<T>)o).subscribe(new Subscriber<T>() {
             @Override
             public void onNext(T t) {
-                
+                // deliberately ignored
             }
             @Override
             public void onError(Throwable e) {
@@ -495,11 +496,7 @@ public void onCompleted() {
         BlockingUtils.awaitForComplete(cdl, s);
         Throwable e = error[0];
         if (e != null) {
-            if (e instanceof RuntimeException) {
-                throw (RuntimeException)e;
-            } else {
-                throw new RuntimeException(e);
-            }
+            Exceptions.propagate(e);
         }
     }
     
@@ -546,15 +543,6 @@ public void onCompleted() {
         }
     }
     
-    /** Constant to indicate the onStart method should be called. */
-    static final Object ON_START = new Object();
-
-    /** Constant indicating the setProducer method should be called. */
-    static final Object SET_PRODUCER = new Object();
-
-    /** Indicates an unsubscription happened */
-    static final Object UNSUBSCRIBE = new Object();
-
     /**
      * Subscribes to the source and calls the Subscriber methods on the current thread.
      * <p>
diff --git a/src/main/java/rx/observables/SyncOnSubscribe.java b/src/main/java/rx/observables/SyncOnSubscribe.java
index 34745fb118..6876b1ef31 100644
--- a/src/main/java/rx/observables/SyncOnSubscribe.java
+++ b/src/main/java/rx/observables/SyncOnSubscribe.java
@@ -105,7 +105,7 @@ public final void call(final Subscriber<? super T> subscriber) {
      *            {@link #next(Object, Observer) next(S, Observer&lt;T&gt;)} before unsubscribe.
      */
     protected void onUnsubscribe(S state) {
-
+        // default behavior is no-op
     }
 
     /**
@@ -279,7 +279,7 @@ public void call(Void t) {
      * @param <T>
      *            the type of compatible Subscribers
      */
-    private static final class SyncOnSubscribeImpl<S, T> extends SyncOnSubscribe<S, T> {
+    static final class SyncOnSubscribeImpl<S, T> extends SyncOnSubscribe<S, T> {
         private final Func0<? extends S> generator;
         private final Func2<? super S, ? super Observer<? super T>, ? extends S> next;
         private final Action1<? super S> onUnsubscribe;
@@ -314,8 +314,9 @@ protected S next(S state, Observer<? super T> observer) {
 
         @Override
         protected void onUnsubscribe(S state) {
-            if (onUnsubscribe != null)
+            if (onUnsubscribe != null) {
                 onUnsubscribe.call(state);
+            }
         }
     }
 
@@ -325,7 +326,7 @@ protected void onUnsubscribe(S state) {
      * @param <T>
      *            the type of compatible Subscribers
      */
-    private static class SubscriptionProducer<S, T> 
+    static final class SubscriptionProducer<S, T> 
     extends AtomicLong implements Producer, Subscription, Observer<T> {
         /** */
         private static final long serialVersionUID = -3736864024352728072L;
@@ -355,11 +356,12 @@ public void unsubscribe() {
                     doUnsubscribe();
                     return;
                 }
-                else if (compareAndSet(requestCount, -2L))
+                else if (compareAndSet(requestCount, -2L)) {
                     // the loop is iterating concurrently
                     // need to check if requestCount == -1
                     // and unsub if so after loop iteration
                     return;
+                }
             }
         }
         
@@ -440,12 +442,14 @@ private void slowPath(long n) {
                     if (tryUnsubscribe()) {
                         return;
                     }
-                    if (onNextCalled)
+                    if (onNextCalled) {
                         numRemaining--;
+                    }
                 } while (numRemaining != 0L);
                 numRequested = addAndGet(-numRequested);
-                if (numRequested <= 0L)
+                if (numRequested <= 0L) {
                     break;
+                }
             }
             // catches cases where unsubscribe is called before decrementing atomic request count
             tryUnsubscribe();
diff --git a/src/main/java/rx/observers/AsyncCompletableSubscriber.java b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
index d61585e4fa..67ebf8a283 100644
--- a/src/main/java/rx/observers/AsyncCompletableSubscriber.java
+++ b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
@@ -58,6 +58,10 @@
  */
 @Experimental
 public abstract class AsyncCompletableSubscriber implements CompletableSubscriber, Subscription {
+    /**
+     * Indicates the unsubscribed state.
+     */
+    static final Unsubscribed UNSUBSCRIBED = new Unsubscribed();
 
     /** 
      * Holds onto a deferred subscription and allows asynchronous cancellation before the call
@@ -81,6 +85,7 @@ public final void onSubscribe(Subscription d) {
      * Called before the first onSubscribe() call succeeds.
      */
     protected void onStart() {
+        // default behavior is no op
     }
     
     @Override
@@ -107,11 +112,6 @@ public final void unsubscribe() {
         
     }
     
-    /**
-     * Indicates the unsubscribed state.
-     */
-    static final Unsubscribed UNSUBSCRIBED = new Unsubscribed();
-    
     static final class Unsubscribed implements Subscription {
 
         @Override
diff --git a/src/main/java/rx/observers/SafeSubscriber.java b/src/main/java/rx/observers/SafeSubscriber.java
index e2df6ffe96..78a39e78f2 100644
--- a/src/main/java/rx/observers/SafeSubscriber.java
+++ b/src/main/java/rx/observers/SafeSubscriber.java
@@ -64,7 +64,7 @@ public class SafeSubscriber<T> extends Subscriber<T> {
 
     private final Subscriber<? super T> actual;
 
-    boolean done = false;
+    boolean done;
 
     public SafeSubscriber(Subscriber<? super T> actual) {
         super(actual);
@@ -88,7 +88,7 @@ public void onCompleted() {
                 Exceptions.throwIfFatal(e);
                 RxJavaPluginUtils.handleException(e);
                 throw new OnCompletedFailedException(e.getMessage(), e);
-            } finally {
+            } finally { // NOPMD 
                 try {
                     // Similarly to onError if failure occurs in unsubscribe then Rx contract is broken
                     // and we throw an UnsubscribeFailureException.
@@ -151,51 +151,49 @@ public void onNext(T args) {
      * 
      * @see <a href="https://github.com/ReactiveX/RxJava/issues/630">the report of this bug</a>
      */
-    protected void _onError(Throwable e) {
+    protected void _onError(Throwable e) { // NOPMD 
         RxJavaPluginUtils.handleException(e);
         try {
             actual.onError(e);
+        } catch (OnErrorNotImplementedException e2) { // NOPMD 
+            /*
+             * onError isn't implemented so throw
+             * 
+             * https://github.com/ReactiveX/RxJava/issues/198
+             * 
+             * Rx Design Guidelines 5.2
+             * 
+             * "when calling the Subscribe method that only has an onNext argument, the OnError behavior
+             * will be to rethrow the exception on the thread that the message comes out from the observable
+             * sequence. The OnCompleted behavior in this case is to do nothing."
+             */
+            try {
+                unsubscribe();
+            } catch (Throwable unsubscribeException) {
+                RxJavaPluginUtils.handleException(unsubscribeException);
+                throw new OnErrorNotImplementedException("Observer.onError not implemented and error while unsubscribing.", new CompositeException(Arrays.asList(e, unsubscribeException))); // NOPMD 
+            }
+            throw e2;
         } catch (Throwable e2) {
-            if (e2 instanceof OnErrorNotImplementedException) {
-                /*
-                 * onError isn't implemented so throw
-                 * 
-                 * https://github.com/ReactiveX/RxJava/issues/198
-                 * 
-                 * Rx Design Guidelines 5.2
-                 * 
-                 * "when calling the Subscribe method that only has an onNext argument, the OnError behavior
-                 * will be to rethrow the exception on the thread that the message comes out from the observable
-                 * sequence. The OnCompleted behavior in this case is to do nothing."
-                 */
-                try {
-                    unsubscribe();
-                } catch (Throwable unsubscribeException) {
-                    RxJavaPluginUtils.handleException(unsubscribeException);
-                    throw new RuntimeException("Observer.onError not implemented and error while unsubscribing.", new CompositeException(Arrays.asList(e, unsubscribeException)));
-                }
-                throw (OnErrorNotImplementedException) e2;
-            } else {
-                /*
-                 * throw since the Rx contract is broken if onError failed
-                 * 
-                 * https://github.com/ReactiveX/RxJava/issues/198
-                 */
-                RxJavaPluginUtils.handleException(e2);
-                try {
-                    unsubscribe();
-                } catch (Throwable unsubscribeException) {
-                    RxJavaPluginUtils.handleException(unsubscribeException);
-                    throw new OnErrorFailedException("Error occurred when trying to propagate error to Observer.onError and during unsubscription.", new CompositeException(Arrays.asList(e, e2, unsubscribeException)));
-                }
-
-                throw new OnErrorFailedException("Error occurred when trying to propagate error to Observer.onError", new CompositeException(Arrays.asList(e, e2)));
+            /*
+             * throw since the Rx contract is broken if onError failed
+             * 
+             * https://github.com/ReactiveX/RxJava/issues/198
+             */
+            RxJavaPluginUtils.handleException(e2);
+            try {
+                unsubscribe();
+            } catch (Throwable unsubscribeException) {
+                RxJavaPluginUtils.handleException(unsubscribeException);
+                throw new OnErrorFailedException("Error occurred when trying to propagate error to Observer.onError and during unsubscription.", new CompositeException(Arrays.asList(e, e2, unsubscribeException)));
             }
+
+            throw new OnErrorFailedException("Error occurred when trying to propagate error to Observer.onError", new CompositeException(Arrays.asList(e, e2)));
         }
         // if we did not throw above we will unsubscribe here, if onError failed then unsubscribe happens in the catch
         try {
             unsubscribe();
-        } catch (RuntimeException unsubscribeException) {
+        } catch (Throwable unsubscribeException) {
             RxJavaPluginUtils.handleException(unsubscribeException);
             throw new OnErrorFailedException(unsubscribeException);
         }
diff --git a/src/main/java/rx/observers/TestObserver.java b/src/main/java/rx/observers/TestObserver.java
index fa7d19dd61..b46cbd8941 100644
--- a/src/main/java/rx/observers/TestObserver.java
+++ b/src/main/java/rx/observers/TestObserver.java
@@ -30,9 +30,9 @@
 public class TestObserver<T> implements Observer<T> {
 
     private final Observer<T> delegate;
-    private final ArrayList<T> onNextEvents = new ArrayList<T>();
-    private final ArrayList<Throwable> onErrorEvents = new ArrayList<Throwable>();
-    private final ArrayList<Notification<T>> onCompletedEvents = new ArrayList<Notification<T>>();
+    private final List<T> onNextEvents = new ArrayList<T>();
+    private final List<Throwable> onErrorEvents = new ArrayList<Throwable>();
+    private final List<Notification<T>> onCompletedEvents = new ArrayList<Notification<T>>();
 
     public TestObserver(Observer<T> delegate) {
         this.delegate = delegate;
@@ -160,7 +160,7 @@ public void assertTerminalEvent() {
             assertionError("Received both an onError and onCompleted. Should be one or the other.");
         }
 
-        if (onCompletedEvents.size() == 0 && onErrorEvents.size() == 0) {
+        if (onCompletedEvents.isEmpty() && onErrorEvents.isEmpty()) {
             assertionError("No terminal events received.");
         }
     }
@@ -173,17 +173,16 @@ public void assertTerminalEvent() {
     final void assertionError(String message) {
         StringBuilder b = new StringBuilder(message.length() + 32);
         
-        b.append(message);
+        b.append(message)
+        .append(" (");
         
-        
-        b.append(" (");
         int c = onCompletedEvents.size();
-        b.append(c);
-        b.append(" completion");
+        b.append(c)
+        .append(" completion");
         if (c != 1) {
-            b.append("s");
+            b.append('s');
         }
-        b.append(")");
+        b.append(')');
         
         if (!onErrorEvents.isEmpty()) {
             int size = onErrorEvents.size();
@@ -191,9 +190,9 @@ final void assertionError(String message) {
             .append(size)
             .append(" error");
             if (size != 1) {
-                b.append("s");
+                b.append('s');
             }
-            b.append(")");
+            b.append(')');
         }
         
         AssertionError ae = new AssertionError(b.toString());
@@ -208,21 +207,21 @@ final void assertionError(String message) {
     }
     
     // do nothing ... including swallowing errors
-    private static Observer<Object> INERT = new Observer<Object>() {
+    private static final Observer<Object> INERT = new Observer<Object>() {
 
         @Override
         public void onCompleted() {
-            
+            // deliberately ignored
         }
 
         @Override
         public void onError(Throwable e) {
-            
+            // deliberately ignored
         }
 
         @Override
         public void onNext(Object t) {
-            
+             // deliberately ignored
         }
         
     };
diff --git a/src/main/java/rx/observers/TestSubscriber.java b/src/main/java/rx/observers/TestSubscriber.java
index ce973fe861..c40593af55 100644
--- a/src/main/java/rx/observers/TestSubscriber.java
+++ b/src/main/java/rx/observers/TestSubscriber.java
@@ -383,7 +383,7 @@ public void assertTerminalEvent() {
             assertionError("Received both an onError and onCompleted. Should be one or the other.");
         }
 
-        if (completions == 0 && errors.size() == 0) {
+        if (completions == 0 && errors.isEmpty()) {
             assertionError("No terminal events received.");
         }
     }
@@ -408,7 +408,7 @@ public void assertUnsubscribed() {
      */
     public void assertNoErrors() {
         List<Throwable> onErrorEvents = getOnErrorEvents();
-        if (onErrorEvents.size() > 0) {
+        if (!onErrorEvents.isEmpty()) {
             assertionError("Unexpected onError events");
         }
     }
@@ -425,7 +425,7 @@ public void awaitTerminalEvent() {
         try {
             latch.await();
         } catch (InterruptedException e) {
-            throw new RuntimeException("Interrupted", e);
+            throw new IllegalStateException("Interrupted", e);
         }
     }
 
@@ -444,7 +444,7 @@ public void awaitTerminalEvent(long timeout, TimeUnit unit) {
         try {
             latch.await(timeout, unit);
         } catch (InterruptedException e) {
-            throw new RuntimeException("Interrupted", e);
+            throw new IllegalStateException("Interrupted", e);
         }
     }
 
@@ -524,7 +524,7 @@ public void assertNotCompleted() {
      */
     public void assertError(Class<? extends Throwable> clazz) {
         List<Throwable> err = errors;
-        if (err.size() == 0) {
+        if (err.isEmpty()) {
             assertionError("No errors");
         } else
         if (err.size() > 1) {
@@ -549,7 +549,7 @@ public void assertError(Class<? extends Throwable> clazz) {
      */
     public void assertError(Throwable throwable) {
         List<Throwable> err = errors;
-        if (err.size() == 0) {
+        if (err.isEmpty()) {
             assertionError("No errors");
         } else
         if (err.size() > 1) {
@@ -569,7 +569,7 @@ public void assertError(Throwable throwable) {
     public void assertNoTerminalEvent() {
         List<Throwable> err = errors;
         int s = completions;
-        if (err.size() > 0 || s > 0) {
+        if (!err.isEmpty() || s > 0) {
             if (err.isEmpty()) {
                 assertionError("Found " + err.size() + " errors and " + s + " completion events instead of none");
             } else
@@ -638,17 +638,16 @@ public void assertValue(T value) {
     final void assertionError(String message) {
         StringBuilder b = new StringBuilder(message.length() + 32);
         
-        b.append(message);
+        b.append(message)
+        .append(" (");
         
-        
-        b.append(" (");
         int c = completions;
-        b.append(c);
-        b.append(" completion");
+        b.append(c)
+        .append(" completion");
         if (c != 1) {
-            b.append("s");
+            b.append('s');
         }
-        b.append(")");
+        b.append(')');
         
         if (!errors.isEmpty()) {
             int size = errors.size();
@@ -656,9 +655,9 @@ final void assertionError(String message) {
             .append(size)
             .append(" error");
             if (size != 1) {
-                b.append("s");
+                b.append('s');
             }
-            b.append(")");
+            b.append(')');
         }
         
         AssertionError ae = new AssertionError(b.toString());
diff --git a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
index 287289242d..7faf996724 100644
--- a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
@@ -38,7 +38,7 @@
  * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
  */
 @Experimental
-public abstract class RxJavaCompletableExecutionHook {
+public abstract class RxJavaCompletableExecutionHook { // NOPMD 
     /**
      * Invoked during the construction by {@link Completable#create(Completable.CompletableOnSubscribe)}
      * <p>
diff --git a/src/main/java/rx/plugins/RxJavaErrorHandler.java b/src/main/java/rx/plugins/RxJavaErrorHandler.java
index 8107fab457..f6ca781d1b 100644
--- a/src/main/java/rx/plugins/RxJavaErrorHandler.java
+++ b/src/main/java/rx/plugins/RxJavaErrorHandler.java
@@ -31,7 +31,9 @@
  * See {@link RxJavaPlugins} or the RxJava GitHub Wiki for information on configuring plugins: <a
  * href="https://github.com/ReactiveX/RxJava/wiki/Plugins">https://github.com/ReactiveX/RxJava/wiki/Plugins</a>.
  */
-public abstract class RxJavaErrorHandler {
+public abstract class RxJavaErrorHandler { // NOPMD 
+
+    protected static final String ERROR_IN_RENDERING_SUFFIX = ".errorRendering";
 
     /**
      * Receives all {@code Exception}s from an {@link Observable} passed to
@@ -48,8 +50,6 @@ public void handleError(Throwable e) {
         // do nothing by default
     }
 
-    protected static final String ERROR_IN_RENDERING_SUFFIX = ".errorRendering";
-
     /**
      * Receives items causing {@code OnErrorThrowable.OnNextValue} and gives a chance to choose the String
      * representation of the item in the {@code OnNextValue} stacktrace rendering. Returns {@code null} if this
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index a5b621ea19..34f58a4947 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -33,11 +33,6 @@
  */
 @Experimental
 public final class RxJavaHooks {
-    /** Utility class. */
-    private RxJavaHooks() {
-        throw new IllegalStateException("No instances!");
-    }
-    
     /**
      * Prevents changing the hook callbacks when set to true.
      */
@@ -77,7 +72,13 @@ private RxJavaHooks() {
     static {
         init();
     }
+
+    /** Utility class. */
+    private RxJavaHooks() {
+        throw new IllegalStateException("No instances!");
+    }
     
+
     /**
      * Initialize the hooks via delegating to RxJavaPlugins.
      */
diff --git a/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index 8c08851ed5..7996e1f3e9 100644
--- a/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -39,7 +39,7 @@
  * worker threads.
  * 
  */
-public abstract class RxJavaObservableExecutionHook {
+public abstract class RxJavaObservableExecutionHook { // NOPMD 
     /**
      * Invoked during the construction by {@link Observable#create(OnSubscribe)}
      * <p>
diff --git a/src/main/java/rx/plugins/RxJavaObservableExecutionHookDefault.java b/src/main/java/rx/plugins/RxJavaObservableExecutionHookDefault.java
index 43dde33a26..f8cfa5e4f5 100644
--- a/src/main/java/rx/plugins/RxJavaObservableExecutionHookDefault.java
+++ b/src/main/java/rx/plugins/RxJavaObservableExecutionHookDefault.java
@@ -18,10 +18,15 @@
 /**
  * Default no-op implementation of {@link RxJavaObservableExecutionHook}
  */
-/* package */class RxJavaObservableExecutionHookDefault extends RxJavaObservableExecutionHook {
+/* package */final class RxJavaObservableExecutionHookDefault extends RxJavaObservableExecutionHook {
 
-    private static RxJavaObservableExecutionHookDefault INSTANCE = new RxJavaObservableExecutionHookDefault();
+    private static final RxJavaObservableExecutionHookDefault INSTANCE = new RxJavaObservableExecutionHookDefault();
 
+    /** Utility class. */
+    private RxJavaObservableExecutionHookDefault() {
+        
+    }
+    
     public static RxJavaObservableExecutionHook getInstance() {
         return INSTANCE;
     }
diff --git a/src/main/java/rx/plugins/RxJavaPlugins.java b/src/main/java/rx/plugins/RxJavaPlugins.java
index 9271a42ce2..184b4fdb1d 100644
--- a/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -58,6 +58,9 @@ public class RxJavaPlugins {
     private final AtomicReference<RxJavaCompletableExecutionHook> completableExecutionHook = new AtomicReference<RxJavaCompletableExecutionHook>();
     private final AtomicReference<RxJavaSchedulersHook> schedulersHook = new AtomicReference<RxJavaSchedulersHook>();
 
+    static final RxJavaErrorHandler DEFAULT_ERROR_HANDLER = new RxJavaErrorHandler() {
+    };
+
     /**
      * Retrieves the single {@code RxJavaPlugins} instance.
      *
@@ -71,7 +74,7 @@ public static RxJavaPlugins getInstance() {
     }
 
     /* package accessible for unit tests */RxJavaPlugins() {
-
+        // nothing to do
     }
     
     /**
@@ -91,9 +94,6 @@ public void reset() {
         INSTANCE.schedulersHook.set(null);
     }
 
-    static final RxJavaErrorHandler DEFAULT_ERROR_HANDLER = new RxJavaErrorHandler() {
-    };
-
     /**
      * Retrieves an instance of {@link RxJavaErrorHandler} to use based on order of precedence as defined in
      * {@link RxJavaPlugins} class header.
@@ -277,14 +277,14 @@ public void registerCompletableExecutionHook(RxJavaCompletableExecutionHook impl
          * System.getProperties as it will never get called in normal operations.
          */
         
-        final String pluginPrefix = "rxjava.plugin.";
+        String pluginPrefix = "rxjava.plugin.";
         
         String defaultKey = pluginPrefix + classSimpleName + ".implementation";
         String implementingClass = props.getProperty(defaultKey);
 
         if (implementingClass == null) {
-            final String classSuffix = ".class";
-            final String implSuffix = ".impl";
+            String classSuffix = ".class";
+            String implSuffix = ".impl";
     
             for (Map.Entry<Object, Object> e : props.entrySet()) {
                 String key = e.getKey().toString();
@@ -299,7 +299,7 @@ public void registerCompletableExecutionHook(RxJavaCompletableExecutionHook impl
                         implementingClass = props.getProperty(implKey);
                         
                         if (implementingClass == null) {
-                            throw new RuntimeException("Implementing class declaration for " + classSimpleName + " missing: " + implKey);
+                            throw new IllegalStateException("Implementing class declaration for " + classSimpleName + " missing: " + implKey);
                         }
                         
                         break;
@@ -315,13 +315,13 @@ public void registerCompletableExecutionHook(RxJavaCompletableExecutionHook impl
                 cls = cls.asSubclass(pluginClass);
                 return cls.newInstance();
             } catch (ClassCastException e) {
-                throw new RuntimeException(classSimpleName + " implementation is not an instance of " + classSimpleName + ": " + implementingClass);
+                throw new IllegalStateException(classSimpleName + " implementation is not an instance of " + classSimpleName + ": " + implementingClass, e);
             } catch (ClassNotFoundException e) {
-                throw new RuntimeException(classSimpleName + " implementation class not found: " + implementingClass, e);
+                throw new IllegalStateException(classSimpleName + " implementation class not found: " + implementingClass, e);
             } catch (InstantiationException e) {
-                throw new RuntimeException(classSimpleName + " implementation not able to be instantiated: " + implementingClass, e);
+                throw new IllegalStateException(classSimpleName + " implementation not able to be instantiated: " + implementingClass, e);
             } catch (IllegalAccessException e) {
-                throw new RuntimeException(classSimpleName + " implementation not able to be accessed: " + implementingClass, e);
+                throw new IllegalStateException(classSimpleName + " implementation not able to be accessed: " + implementingClass, e);
             }
         }
 
diff --git a/src/main/java/rx/plugins/RxJavaSchedulersHook.java b/src/main/java/rx/plugins/RxJavaSchedulersHook.java
index a8158e2f5e..cc1675f322 100644
--- a/src/main/java/rx/plugins/RxJavaSchedulersHook.java
+++ b/src/main/java/rx/plugins/RxJavaSchedulersHook.java
@@ -42,6 +42,8 @@
  */
 public class RxJavaSchedulersHook {
 
+    private final static RxJavaSchedulersHook DEFAULT_INSTANCE = new RxJavaSchedulersHook();
+
     /**
      * Create an instance of the default {@link Scheduler} used for {@link Schedulers#computation()}.
      * @return the created Scheduler instance
@@ -59,7 +61,9 @@ public static Scheduler createComputationScheduler() {
      */
     @Experimental
     public static Scheduler createComputationScheduler(ThreadFactory threadFactory) {
-        if (threadFactory == null) throw new NullPointerException("threadFactory == null");
+        if (threadFactory == null) {
+            throw new NullPointerException("threadFactory == null");
+        }
         return new EventLoopsScheduler(threadFactory);
     }
 
@@ -80,7 +84,9 @@ public static Scheduler createIoScheduler() {
      */
     @Experimental
     public static Scheduler createIoScheduler(ThreadFactory threadFactory) {
-        if (threadFactory == null) throw new NullPointerException("threadFactory == null");
+        if (threadFactory == null) {
+            throw new NullPointerException("threadFactory == null");
+        }
         return new CachedThreadScheduler(threadFactory);
     }
 
@@ -101,16 +107,12 @@ public static Scheduler createNewThreadScheduler() {
      */
     @Experimental
     public static Scheduler createNewThreadScheduler(ThreadFactory threadFactory) {
-        if (threadFactory == null) throw new NullPointerException("threadFactory == null");
+        if (threadFactory == null) {
+            throw new NullPointerException("threadFactory == null");
+        }
         return new NewThreadScheduler(threadFactory);
     }
 
-    protected RxJavaSchedulersHook() {
-
-    }
-
-    private final static RxJavaSchedulersHook DEFAULT_INSTANCE = new RxJavaSchedulersHook();
-
     /**
      * Scheduler to return from {@link rx.schedulers.Schedulers#computation()} or null if default should be
      * used.
diff --git a/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java b/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
index 4e023f615e..809a968f6b 100644
--- a/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
@@ -38,7 +38,7 @@
  * worker threads.
  *
  */
-public abstract class RxJavaSingleExecutionHook {
+public abstract class RxJavaSingleExecutionHook { // NOPMD 
     /**
      * Invoked during the construction by {@link Single#create(Single.OnSubscribe)}
      * <p>
diff --git a/src/main/java/rx/plugins/RxJavaSingleExecutionHookDefault.java b/src/main/java/rx/plugins/RxJavaSingleExecutionHookDefault.java
index 60a382589f..dd09ecfc79 100644
--- a/src/main/java/rx/plugins/RxJavaSingleExecutionHookDefault.java
+++ b/src/main/java/rx/plugins/RxJavaSingleExecutionHookDefault.java
@@ -18,10 +18,16 @@
 /**
  * Default no-op implementation of {@link RxJavaSingleExecutionHook}
  */
-class RxJavaSingleExecutionHookDefault extends RxJavaSingleExecutionHook {
+final class RxJavaSingleExecutionHookDefault extends RxJavaSingleExecutionHook {
 
     private static final RxJavaSingleExecutionHookDefault INSTANCE = new RxJavaSingleExecutionHookDefault();
 
+    /**
+     * Utility class.
+     */
+    private RxJavaSingleExecutionHookDefault() {
+    }
+    
     public static RxJavaSingleExecutionHook getInstance() {
         return INSTANCE;
     }
diff --git a/src/main/java/rx/schedulers/ImmediateScheduler.java b/src/main/java/rx/schedulers/ImmediateScheduler.java
index 2696859987..a187a5aa51 100644
--- a/src/main/java/rx/schedulers/ImmediateScheduler.java
+++ b/src/main/java/rx/schedulers/ImmediateScheduler.java
@@ -22,7 +22,7 @@
  */
 @Deprecated
 // Class was part of public API.
-public final class ImmediateScheduler extends Scheduler {
+public final class ImmediateScheduler extends Scheduler { // NOPMD 
     private ImmediateScheduler() {
         throw new AssertionError();
     }
diff --git a/src/main/java/rx/schedulers/NewThreadScheduler.java b/src/main/java/rx/schedulers/NewThreadScheduler.java
index fc709243f0..a8d3221d3d 100644
--- a/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -22,7 +22,7 @@
  */
 @Deprecated
 // Class was part of public API.
-public final class NewThreadScheduler extends Scheduler {
+public final class NewThreadScheduler extends Scheduler { // NOPMD 
     private NewThreadScheduler() {
         throw new AssertionError();
     }
diff --git a/src/main/java/rx/schedulers/Schedulers.java b/src/main/java/rx/schedulers/Schedulers.java
index 6dc89f0178..5155dfb297 100644
--- a/src/main/java/rx/schedulers/Schedulers.java
+++ b/src/main/java/rx/schedulers/Schedulers.java
@@ -146,7 +146,7 @@ public static Scheduler io() {
      *
      * @return a {@code TestScheduler} meant for debugging
      */
-    public static TestScheduler test() {
+    public static TestScheduler test() { // NOPMD 
         return new TestScheduler();
     }
 
@@ -211,7 +211,7 @@ public static void shutdown() {
     /**
      * Start the instance-specific schedulers.
      */
-    synchronized void startInstance() {
+    synchronized void startInstance() { // NOPMD 
         if (computationScheduler instanceof SchedulerLifecycle) {
             ((SchedulerLifecycle) computationScheduler).start();
         }
@@ -226,7 +226,7 @@ synchronized void startInstance() {
     /**
      * Start the instance-specific schedulers.
      */
-    synchronized void shutdownInstance() {
+    synchronized void shutdownInstance() { // NOPMD 
         if (computationScheduler instanceof SchedulerLifecycle) {
             ((SchedulerLifecycle) computationScheduler).shutdown();
         }
diff --git a/src/main/java/rx/schedulers/TestScheduler.java b/src/main/java/rx/schedulers/TestScheduler.java
index fec8bbcd75..b4d3b6e9af 100644
--- a/src/main/java/rx/schedulers/TestScheduler.java
+++ b/src/main/java/rx/schedulers/TestScheduler.java
@@ -32,9 +32,13 @@
  */
 public class TestScheduler extends Scheduler {
     final Queue<TimedAction> queue = new PriorityQueue<TimedAction>(11, new CompareActionsByTime());
-    static long counter = 0;
+    
+    static long counter;
+    
+    // Storing time in nanoseconds internally.
+    long time;
 
-    private static final class TimedAction {
+    static final class TimedAction {
 
         final long time;
         final Action0 action;
@@ -53,9 +57,7 @@ public String toString() {
         }
     }
 
-    private static class CompareActionsByTime implements Comparator<TimedAction> {
-        CompareActionsByTime() {
-        }
+    static final class CompareActionsByTime implements Comparator<TimedAction> {
 
         @Override
         public int compare(TimedAction action1, TimedAction action2) {
@@ -67,9 +69,6 @@ public int compare(TimedAction action1, TimedAction action2) {
         }
     }
 
-    // Storing time in nanoseconds internally.
-    long time;
-
     @Override
     public long now() {
         return TimeUnit.NANOSECONDS.toMillis(time);
@@ -131,13 +130,10 @@ public Worker createWorker() {
         return new InnerTestScheduler();
     }
 
-    private final class InnerTestScheduler extends Worker {
+    final class InnerTestScheduler extends Worker {
 
         private final BooleanSubscription s = new BooleanSubscription();
 
-        InnerTestScheduler() {
-        }
-
         @Override
         public void unsubscribe() {
             s.unsubscribe();
diff --git a/src/main/java/rx/schedulers/TimeInterval.java b/src/main/java/rx/schedulers/TimeInterval.java
index 2123abaa0b..b5e7760c3d 100644
--- a/src/main/java/rx/schedulers/TimeInterval.java
+++ b/src/main/java/rx/schedulers/TimeInterval.java
@@ -61,7 +61,7 @@ public T getValue() {
     // The following methods are generated by eclipse automatically.
     @Override
     public int hashCode() {
-        final int prime = 31;
+        int prime = 31;
         int result = 1;
         result = prime
                 * result
@@ -72,20 +72,26 @@ public int hashCode() {
 
     @Override
     public boolean equals(Object obj) {
-        if (this == obj)
+        if (this == obj) {
             return true;
-        if (obj == null)
+        }
+        if (obj == null) {
             return false;
-        if (getClass() != obj.getClass())
+        }
+        if (getClass() != obj.getClass()) {
             return false;
+        }
         TimeInterval<?> other = (TimeInterval<?>) obj;
-        if (intervalInMilliseconds != other.intervalInMilliseconds)
+        if (intervalInMilliseconds != other.intervalInMilliseconds) {
             return false;
+        }
         if (value == null) {
-            if (other.value != null)
+            if (other.value != null) {
                 return false;
-        } else if (!value.equals(other.value))
+            }
+        } else if (!value.equals(other.value)) {
             return false;
+        }
         return true;
     }
 
diff --git a/src/main/java/rx/schedulers/Timestamped.java b/src/main/java/rx/schedulers/Timestamped.java
index fee18b7976..f741ccbc4a 100644
--- a/src/main/java/rx/schedulers/Timestamped.java
+++ b/src/main/java/rx/schedulers/Timestamped.java
@@ -73,7 +73,7 @@ public boolean equals(Object obj) {
 
     @Override
     public int hashCode() {
-        final int prime = 31;
+        int prime = 31;
         int result = 1;
         result = prime * result + (int) (timestampMillis ^ (timestampMillis >>> 32));
         result = prime * result + ((value == null) ? 0 : value.hashCode());
diff --git a/src/main/java/rx/schedulers/TrampolineScheduler.java b/src/main/java/rx/schedulers/TrampolineScheduler.java
index bb28916123..d14e0d2cb8 100644
--- a/src/main/java/rx/schedulers/TrampolineScheduler.java
+++ b/src/main/java/rx/schedulers/TrampolineScheduler.java
@@ -22,7 +22,7 @@
  */
 @Deprecated
 // Class was part of public API.
-public final class TrampolineScheduler extends Scheduler {
+public final class TrampolineScheduler extends Scheduler { // NOPMD 
     private TrampolineScheduler() {
         throw new AssertionError();
     }
diff --git a/src/main/java/rx/singles/BlockingSingle.java b/src/main/java/rx/singles/BlockingSingle.java
index 1cd0605a33..2c14498b87 100644
--- a/src/main/java/rx/singles/BlockingSingle.java
+++ b/src/main/java/rx/singles/BlockingSingle.java
@@ -20,6 +20,7 @@
 import rx.SingleSubscriber;
 import rx.Subscription;
 import rx.annotations.Experimental;
+import rx.exceptions.Exceptions;
 import rx.internal.operators.BlockingOperatorToFuture;
 import rx.internal.util.BlockingUtils;
 
@@ -35,9 +36,10 @@
  * or {@link Single#toBlocking()}.
  * 
  * @param <T> the value type of the sequence
+ * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
  */
 @Experimental
-public class BlockingSingle<T> {
+public final class BlockingSingle<T> {
     private final Single<? extends T> single;
 
     private BlockingSingle(Single<? extends T> single) {
@@ -88,10 +90,7 @@ public void onError(Throwable error) {
         BlockingUtils.awaitForComplete(latch, subscription);
         Throwable throwable = returnException.get();
         if (throwable != null) {
-            if (throwable instanceof RuntimeException) {
-                throw (RuntimeException) throwable;
-            }
-            throw new RuntimeException(throwable);
+            throw Exceptions.propagate(throwable);
         }
         return returnItem.get();
     }
diff --git a/src/main/java/rx/subjects/AsyncSubject.java b/src/main/java/rx/subjects/AsyncSubject.java
index 26057b6821..07a8440232 100644
--- a/src/main/java/rx/subjects/AsyncSubject.java
+++ b/src/main/java/rx/subjects/AsyncSubject.java
@@ -58,6 +58,9 @@
  *          the type of item expected to be observed by the Subject
  */
 public final class AsyncSubject<T> extends Subject<T, T> {
+    final SubjectSubscriptionManager<T> state;
+    volatile Object lastValue;
+    private final NotificationLite<T> nl = NotificationLite.instance();
 
     /**
      * Creates and returns a new {@code AsyncSubject}.
@@ -84,10 +87,6 @@ public void call(SubjectObserver<T> o) {
         return new AsyncSubject<T>(state, state);
     }
 
-    final SubjectSubscriptionManager<T> state;
-    volatile Object lastValue;
-    private final NotificationLite<T> nl = NotificationLite.instance();
-
     protected AsyncSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> state) {
         super(onSubscribe);
         this.state = state;
diff --git a/src/main/java/rx/subjects/BehaviorSubject.java b/src/main/java/rx/subjects/BehaviorSubject.java
index ad8bd448f6..1ed4892746 100644
--- a/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/src/main/java/rx/subjects/BehaviorSubject.java
@@ -70,6 +70,11 @@
  *          the type of item expected to be observed by the Subject
  */
 public final class BehaviorSubject<T> extends Subject<T, T> {
+    /** An empty array to trigger getValues() to return a new array. */
+    private static final Object[] EMPTY_ARRAY = new Object[0];
+    private final SubjectSubscriptionManager<T> state;
+    private final NotificationLite<T> nl = NotificationLite.instance();
+
     /**
      * Creates a {@link BehaviorSubject} without a default item.
      *
@@ -111,9 +116,6 @@ public void call(SubjectObserver<T> o) {
         return new BehaviorSubject<T>(state, state); 
     }
 
-    private final SubjectSubscriptionManager<T> state;
-    private final NotificationLite<T> nl = NotificationLite.instance();
-
     protected BehaviorSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> state) {
         super(onSubscribe);
         this.state = state;
@@ -255,9 +257,6 @@ public T[] getValues(T[] a) {
         return a;
     }
     
-    /** An empty array to trigger getValues() to return a new array. */
-    private static final Object[] EMPTY_ARRAY = new Object[0];
-    
     /**
      * Returns a snapshot of the currently buffered non-terminal events.
      * <p>The operation is threadsafe.
diff --git a/src/main/java/rx/subjects/PublishSubject.java b/src/main/java/rx/subjects/PublishSubject.java
index 42a4a18c7c..90fae91c00 100644
--- a/src/main/java/rx/subjects/PublishSubject.java
+++ b/src/main/java/rx/subjects/PublishSubject.java
@@ -50,6 +50,8 @@
  *          the type of items observed and emitted by the Subject
  */
 public final class PublishSubject<T> extends Subject<T, T> {
+    final SubjectSubscriptionManager<T> state;
+    private final NotificationLite<T> nl = NotificationLite.instance();
 
     /**
      * Creates and returns a new {@code PublishSubject}.
@@ -70,9 +72,6 @@ public void call(SubjectObserver<T> o) {
         return new PublishSubject<T>(state, state);
     }
 
-    final SubjectSubscriptionManager<T> state;
-    private final NotificationLite<T> nl = NotificationLite.instance();
-    
     protected PublishSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> state) {
         super(onSubscribe);
         this.state = state;
diff --git a/src/main/java/rx/subjects/ReplaySubject.java b/src/main/java/rx/subjects/ReplaySubject.java
index a842baedbf..63d3001414 100644
--- a/src/main/java/rx/subjects/ReplaySubject.java
+++ b/src/main/java/rx/subjects/ReplaySubject.java
@@ -53,6 +53,10 @@
  *          the type of items observed and emitted by the Subject
  */
 public final class ReplaySubject<T> extends Subject<T, T> {
+    /** The state storing the history and the references. */
+    final ReplayState<T> state;
+    /** An empty array to trigger getValues() to return a new array. */
+    private static final Object[] EMPTY_ARRAY = new Object[0];
     /**
      * Creates an unbounded replay subject.
      * <p>
@@ -229,9 +233,6 @@ public static <T> ReplaySubject<T> createWithTimeAndSize(long time, TimeUnit uni
         return new ReplaySubject<T>(state);
     }
 
-    /** The state storing the history and the references. */
-    final ReplayState<T> state;
-
     ReplaySubject(ReplayState<T> state) {
         super(state);
         this.state = state;
@@ -321,9 +322,6 @@ public T[] getValues(T[] a) {
         return state.buffer.toArray(a);
     }
     
-    /** An empty array to trigger getValues() to return a new array. */
-    private static final Object[] EMPTY_ARRAY = new Object[0];
-    
     /**
      * Returns a snapshot of the currently buffered non-terminal events.
      * <p>The operation is threadsafe.
diff --git a/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 215deb4936..53db3f3684 100644
--- a/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -214,7 +214,7 @@ protected static final class SubjectObserver<T> implements Observer<T> {
         List<Object> queue;
         /* volatile */boolean fastPath;
         /** Indicate that the observer has caught up. */
-        protected volatile boolean caughtUp;
+        volatile boolean caughtUp;
         /** Indicate where the observer is at replaying. */
         private volatile Object index;
         public SubjectObserver(Subscriber<? super T> actual) {
@@ -238,7 +238,7 @@ public void onCompleted() {
          * @param n the NotificationLite value
          * @param nl the type-appropriate notification lite object
          */
-        protected void emitNext(Object n, final NotificationLite<T> nl) {
+        void emitNext(Object n, final NotificationLite<T> nl) {
             if (!fastPath) {
                 synchronized (this) {
                     first = false;
@@ -260,7 +260,7 @@ protected void emitNext(Object n, final NotificationLite<T> nl) {
          * @param n the NotificationLite value
          * @param nl the type-appropriate notification lite object
          */
-        protected void emitFirst(Object n, final NotificationLite<T> nl) {
+        void emitFirst(Object n, final NotificationLite<T> nl) {
             synchronized (this) {
                 if (!first || emitting) {
                     return;
@@ -278,7 +278,7 @@ protected void emitFirst(Object n, final NotificationLite<T> nl) {
          * @param current the current content to emit
          * @param nl the type-appropriate notification lite object
          */
-        protected void emitLoop(List<Object> localQueue, Object current, final NotificationLite<T> nl) {
+        void emitLoop(List<Object> localQueue, Object current, final NotificationLite<T> nl) {
             boolean once = true;
             boolean skipFinal = false;
             try {
@@ -315,14 +315,14 @@ protected void emitLoop(List<Object> localQueue, Object current, final Notificat
          * @param n the value to dispatch
          * @param nl the type-appropriate notification lite object
          */
-        protected void accept(Object n, final NotificationLite<T> nl) {
+        void accept(Object n, final NotificationLite<T> nl) {
             if (n != null) {
                 nl.accept(actual, n);
             }
         }
         
         /** @return the actual Observer. */
-        protected Observer<? super T> getActual() {
+        Observer<? super T> getActual() {
             return actual;
         }
         /**
diff --git a/src/main/java/rx/subjects/TestSubject.java b/src/main/java/rx/subjects/TestSubject.java
index db57feedd4..579173a785 100644
--- a/src/main/java/rx/subjects/TestSubject.java
+++ b/src/main/java/rx/subjects/TestSubject.java
@@ -34,6 +34,9 @@
  *          the type of item observed by and emitted by the subject
  */
 public final class TestSubject<T> extends Subject<T, T> {
+    private final SubjectSubscriptionManager<T> state;
+    private final Scheduler.Worker innerScheduler;
+
 
     /**
      * Creates and returns a new {@code TestSubject}.
@@ -58,9 +61,6 @@ public void call(SubjectObserver<T> o) {
         return new TestSubject<T>(state, state, scheduler);
     }
 
-    private final SubjectSubscriptionManager<T> state;
-    private final Scheduler.Worker innerScheduler;
-
     protected TestSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> state, TestScheduler scheduler) {
         super(onSubscribe);
         this.state = state;
@@ -75,7 +75,7 @@ public void onCompleted() {
         onCompleted(0);
     }
 
-    void _onCompleted() {
+    void internalOnCompleted() {
         if (state.active) {
             for (SubjectObserver<T> bo : state.terminate(NotificationLite.instance().completed())) {
                 bo.onCompleted();
@@ -94,7 +94,7 @@ public void onCompleted(long delayTime) {
 
             @Override
             public void call() {
-                _onCompleted();
+                internalOnCompleted();
             }
 
         }, delayTime, TimeUnit.MILLISECONDS);
@@ -108,7 +108,7 @@ public void onError(final Throwable e) {
         onError(e, 0);
     }
 
-    void _onError(final Throwable e) {
+    void internalOnError(final Throwable e) {
         if (state.active) {
             for (SubjectObserver<T> bo : state.terminate(NotificationLite.instance().error(e))) {
                 bo.onError(e);
@@ -129,7 +129,7 @@ public void onError(final Throwable e, long delayTime) {
 
             @Override
             public void call() {
-                _onError(e);
+                internalOnError(e);
             }
 
         }, delayTime, TimeUnit.MILLISECONDS);
@@ -143,7 +143,7 @@ public void onNext(T v) {
         onNext(v, 0);
     }
 
-    void _onNext(T v) {
+    void internalOnNext(T v) {
         for (Observer<? super T> o : state.observers()) {
             o.onNext(v);
         }
@@ -162,7 +162,7 @@ public void onNext(final T v, long delayTime) {
 
             @Override
             public void call() {
-                _onNext(v);
+                internalOnNext(v);
             }
 
         }, delayTime, TimeUnit.MILLISECONDS);
diff --git a/src/main/java/rx/subjects/UnicastSubject.java b/src/main/java/rx/subjects/UnicastSubject.java
index f401c364f1..57459d72d5 100644
--- a/src/main/java/rx/subjects/UnicastSubject.java
+++ b/src/main/java/rx/subjects/UnicastSubject.java
@@ -38,6 +38,8 @@
 @Experimental
 public final class UnicastSubject<T> extends Subject<T, T> {
 
+    final State<T> state;
+
     /**
      * Constructs an empty UnicastSubject instance with the default capacity hint of 16 elements.
      * 
@@ -80,8 +82,6 @@ public static <T> UnicastSubject<T> create(int capacityHint, Action0 onTerminate
         return new UnicastSubject<T>(state);
     }
 
-    final State<T> state;
-
     private UnicastSubject(State<T> state) {
         super(state);
         this.state = state;
diff --git a/src/main/java/rx/subscriptions/BooleanSubscription.java b/src/main/java/rx/subscriptions/BooleanSubscription.java
index 9ba4100a66..3628e63f91 100644
--- a/src/main/java/rx/subscriptions/BooleanSubscription.java
+++ b/src/main/java/rx/subscriptions/BooleanSubscription.java
@@ -63,7 +63,7 @@ public boolean isUnsubscribed() {
     }
 
     @Override
-    public final void unsubscribe() {
+    public void unsubscribe() {
         Action0 action = actionRef.get();
         if (action != EMPTY_ACTION) {
             action = actionRef.getAndSet(EMPTY_ACTION);
@@ -76,7 +76,7 @@ public final void unsubscribe() {
     static final Action0 EMPTY_ACTION = new Action0() {
         @Override
         public void call() {
-
+            // deliberately no-op
         }
     };
 
diff --git a/src/main/java/rx/subscriptions/CompositeSubscription.java b/src/main/java/rx/subscriptions/CompositeSubscription.java
index 876a04a56b..6b111af15e 100644
--- a/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -35,7 +35,11 @@ public final class CompositeSubscription implements Subscription {
     private Set<Subscription> subscriptions;
     private volatile boolean unsubscribed;
 
+    /**
+     * Constructs an empty Composite subscription.
+     */
     public CompositeSubscription() {
+        // start empty
     }
 
     public CompositeSubscription(final Subscription... subscriptions) {
diff --git a/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java b/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
index ec0ea7c6df..1418a5684c 100644
--- a/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
+++ b/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
@@ -28,7 +28,7 @@ public final class MultipleAssignmentSubscription implements Subscription {
 
     final AtomicReference<State> state = new AtomicReference<State>(new State(false, Subscriptions.empty()));
     
-    private static final class State {
+    static final class State {
         final boolean isUnsubscribed;
         final Subscription subscription;
 
diff --git a/src/main/java/rx/subscriptions/RefCountSubscription.java b/src/main/java/rx/subscriptions/RefCountSubscription.java
index 083b860f04..dbb38716b7 100644
--- a/src/main/java/rx/subscriptions/RefCountSubscription.java
+++ b/src/main/java/rx/subscriptions/RefCountSubscription.java
@@ -29,7 +29,7 @@ public final class RefCountSubscription implements Subscription {
     static final State EMPTY_STATE = new State(false, 0);
     final AtomicReference<State> state = new AtomicReference<State>(EMPTY_STATE);
 
-    private static final class State {
+    static final class State {
         final boolean isUnsubscribed;
         final int children;
 
@@ -125,7 +125,7 @@ void unsubscribeAChild() {
     }
 
     /** The individual sub-subscriptions. */
-    private static final class InnerSubscription extends AtomicInteger implements Subscription {
+    static final class InnerSubscription extends AtomicInteger implements Subscription {
         /** */
         private static final long serialVersionUID = 7005765588239987643L;
         
diff --git a/src/main/java/rx/subscriptions/SerialSubscription.java b/src/main/java/rx/subscriptions/SerialSubscription.java
index f8aff9b67e..b06503f761 100644
--- a/src/main/java/rx/subscriptions/SerialSubscription.java
+++ b/src/main/java/rx/subscriptions/SerialSubscription.java
@@ -26,7 +26,7 @@
 public final class SerialSubscription implements Subscription {
     final AtomicReference<State> state = new AtomicReference<State>(new State(false, Subscriptions.empty()));
 
-    private static final class State {
+    static final class State {
         final boolean isUnsubscribed;
         final Subscription subscription;
 
diff --git a/src/main/java/rx/subscriptions/Subscriptions.java b/src/main/java/rx/subscriptions/Subscriptions.java
index 64d941f13d..db11dfb87b 100644
--- a/src/main/java/rx/subscriptions/Subscriptions.java
+++ b/src/main/java/rx/subscriptions/Subscriptions.java
@@ -24,6 +24,11 @@
  * Helper methods and utilities for creating and working with {@link Subscription} objects
  */
 public final class Subscriptions {
+    /**
+     * A {@link Subscription} that does nothing when its unsubscribe method is called.
+     */
+    private static final Unsubscribed UNSUBSCRIBED = new Unsubscribed();
+
     private Subscriptions() {
         throw new IllegalStateException("No instances!");
     }
@@ -85,7 +90,7 @@ public static Subscription from(final Future<?> f) {
     }
 
         /** Naming classes helps with debugging. */
-    private static final class FutureSubscription implements Subscription {
+    static final class FutureSubscription implements Subscription {
         final Future<?> f;
 
         public FutureSubscription(Future<?> f) {
@@ -115,14 +120,11 @@ public static CompositeSubscription from(Subscription... subscriptions) {
         return new CompositeSubscription(subscriptions);
     }
 
-    /**
-     * A {@link Subscription} that does nothing when its unsubscribe method is called.
-     */
-    private static final Unsubscribed UNSUBSCRIBED = new Unsubscribed();
         /** Naming classes helps with debugging. */
     static final class Unsubscribed implements Subscription {
         @Override
         public void unsubscribe() {
+            // deliberately ignored
         }
 
         @Override
diff --git a/src/perf/java/rx/observables/SyncOnSubscribePerf.java b/src/perf/java/rx/observables/SyncOnSubscribePerf.java
index 91882df8d0..f99a01a421 100644
--- a/src/perf/java/rx/observables/SyncOnSubscribePerf.java
+++ b/src/perf/java/rx/observables/SyncOnSubscribePerf.java
@@ -42,7 +42,7 @@ public static void main(String[] args) {
         SyncOnSubscribePerf perf = new SyncOnSubscribePerf();
         perf.benchSyncOnSubscribe(singleInput);
     }
-    private static class generated {
+    static class generated {
         private static Blackhole _jmh_tryInit_() {
             return new Blackhole();
         }
diff --git a/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java b/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
index 0c72ebaf7a..7942214b0c 100644
--- a/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
@@ -132,7 +132,7 @@ public Worker createWorker() {
             return new SlowInner(actual.createWorker());
         }
 
-        private final class SlowInner extends Worker {
+        final class SlowInner extends Worker {
 
             private final Scheduler.Worker actualInner;
 
diff --git a/src/test/java/rx/util/AssertObservableTest.java b/src/test/java/rx/util/AssertObservableTest.java
index 5f9e9a0ac1..187735a332 100644
--- a/src/test/java/rx/util/AssertObservableTest.java
+++ b/src/test/java/rx/util/AssertObservableTest.java
@@ -15,7 +15,7 @@
  */
 package rx.util;
 
-import org.junit.Test;
+import org.junit.*;
 
 import rx.Observable;
 
@@ -31,13 +31,23 @@ public void testPassNull() {
         AssertObservable.assertObservableEqualsBlocking("foo", null, null);
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test
     public void testFailNotNull() {
-        AssertObservable.assertObservableEqualsBlocking("foo", Observable.just(1, 2), Observable.just(1));
+        try {
+            AssertObservable.assertObservableEqualsBlocking("foo", Observable.just(1, 2), Observable.just(1));
+            Assert.fail("Failed to throw");
+        } catch (AssertionError expected) {
+            // expected
+        }
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test
     public void testFailNull() {
-        AssertObservable.assertObservableEqualsBlocking("foo", Observable.just(1, 2), null);
+        try {
+            AssertObservable.assertObservableEqualsBlocking("foo", Observable.just(1, 2), null);
+            Assert.fail("Failed to throw");
+        } catch (AssertionError expected) {
+            // expected
+        }
     }
 }

From b21504dc248240288faa0820e1240818228a39d7 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 25 Jun 2016 08:05:25 +0200
Subject: [PATCH 080/263] 1.x: add AnimalSniffer to the build process, fix and
 suppress violations (#4092)

* 1.x: add AnimalSniffer to the build process, fix and suppress violations

* Add more time, disable excessive thread use tests

* Demonstrate violation.

* javac obviously fails with 8 methods

* Undo demonstration
---
 build.gradle                                  | 22 ++++++++++++--
 .../internal/schedulers/NewThreadWorker.java  |  1 +
 .../internal/util/SuppressAnimalSniffer.java  | 29 +++++++++++++++++++
 .../rx/internal/util/UtilityFunctions.java    |  3 +-
 .../internal/util/unsafe/BaseLinkedQueue.java |  6 +++-
 .../unsafe/ConcurrentCircularArrayQueue.java  |  8 +++--
 ...ConcurrentSequencedCircularArrayQueue.java |  3 ++
 .../internal/util/unsafe/MpmcArrayQueue.java  |  5 ++++
 .../internal/util/unsafe/MpscLinkedQueue.java |  3 ++
 .../internal/util/unsafe/SpmcArrayQueue.java  |  6 ++++
 .../internal/util/unsafe/SpscArrayQueue.java  |  5 ++++
 .../util/unsafe/SpscUnboundedArrayQueue.java  |  3 ++
 .../rx/internal/util/unsafe/UnsafeAccess.java |  2 ++
 .../operators/OperatorMapPairTest.java        | 15 ++++++++++
 .../operators/OperatorSwitchTest.java         |  4 ++-
 .../java/rx/observers/TestSubscriberTest.java |  2 +-
 .../java/rx/plugins/RxJavaPluginsTest.java    |  2 +-
 .../rx/schedulers/ResetSchedulersTest.java    | 15 ++++++++++
 .../java/rx/subjects/BehaviorSubjectTest.java |  2 +-
 .../java/rx/subjects/PublishSubjectTest.java  |  2 +-
 .../ReplaySubjectBoundedConcurrencyTest.java  |  4 +--
 .../ReplaySubjectConcurrencyTest.java         |  2 +-
 .../java/rx/subjects/ReplaySubjectTest.java   |  2 +-
 23 files changed, 129 insertions(+), 17 deletions(-)
 create mode 100644 src/main/java/rx/internal/util/SuppressAnimalSniffer.java

diff --git a/build.gradle b/build.gradle
index 9f846638b2..0221350605 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,6 +1,11 @@
 buildscript {
-  repositories { jcenter() }
-  dependencies { classpath 'com.netflix.nebula:gradle-rxjava-project-plugin:4.0.0' }
+    repositories { 
+        jcenter() 
+    }
+    dependencies { 
+        classpath 'com.netflix.nebula:gradle-rxjava-project-plugin:4.0.0'
+        classpath 'ru.vyarus:gradle-animalsniffer-plugin:1.1.0' 
+    }
 }
 
 description = 'RxJava: Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.'
@@ -8,9 +13,16 @@ description = 'RxJava: Reactive Extensions for the JVM – a library for composi
 apply plugin: 'java'
 apply plugin: 'pmd'
 apply plugin: 'jacoco'
+apply plugin: 'ru.vyarus.animalsniffer'
 apply plugin: 'nebula.rxjava-project'
 
+repositories {
+    mavenCentral()
+}
+
 dependencies {
+    signature 'org.codehaus.mojo.signature:java16:1.1@signature'
+
     testCompile 'junit:junit:4.12'
     testCompile 'org.mockito:mockito-core:1.10.19'
 
@@ -95,4 +107,8 @@ task pmdPrint(dependsOn: 'pmdMain') << {
     }
 }
 
-build.dependsOn pmdPrint
\ No newline at end of file
+build.dependsOn pmdPrint
+
+animalsniffer {
+    annotation = 'rx.internal.util.SuppressAnimalSniffer'
+}
\ No newline at end of file
diff --git a/src/main/java/rx/internal/schedulers/NewThreadWorker.java b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
index 25517124be..5daf41d05a 100644
--- a/src/main/java/rx/internal/schedulers/NewThreadWorker.java
+++ b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
@@ -109,6 +109,7 @@ public static void deregisterExecutor(ScheduledExecutorService service) {
     }
 
     /** Purges each registered executor and eagerly evicts shutdown executors. */
+    @SuppressAnimalSniffer // CHM.keySet returns KeySetView in Java 8+; false positive here
     static void purgeExecutors() {
         try {
             Iterator<ScheduledThreadPoolExecutor> it = EXECUTORS.keySet().iterator();
diff --git a/src/main/java/rx/internal/util/SuppressAnimalSniffer.java b/src/main/java/rx/internal/util/SuppressAnimalSniffer.java
new file mode 100644
index 0000000000..38a0246bf7
--- /dev/null
+++ b/src/main/java/rx/internal/util/SuppressAnimalSniffer.java
@@ -0,0 +1,29 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.util;
+
+import java.lang.annotation.*;
+
+/**
+ * Suppress errors by the AnimalSniffer plugin.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Documented
+@Target({ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.TYPE})
+public @interface SuppressAnimalSniffer {
+
+}
diff --git a/src/main/java/rx/internal/util/UtilityFunctions.java b/src/main/java/rx/internal/util/UtilityFunctions.java
index adf2c2c011..cf97621de2 100644
--- a/src/main/java/rx/internal/util/UtilityFunctions.java
+++ b/src/main/java/rx/internal/util/UtilityFunctions.java
@@ -12,6 +12,8 @@
  */
 package rx.internal.util;
 
+import java.util.Collections;
+
 import rx.functions.Func0;
 import rx.functions.Func1;
 import rx.functions.Func2;
@@ -178,5 +180,4 @@ public R call(Object... args) {
             return null;
         }
     }
-    
 }
diff --git a/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java b/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
index 8a5c600421..0c644b5f64 100644
--- a/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
@@ -20,6 +20,7 @@
 
 import java.util.*;
 
+import rx.internal.util.SuppressAnimalSniffer;
 import rx.internal.util.atomic.LinkedQueueNode;
 
 abstract class BaseLinkedQueuePad0<E> extends AbstractQueue<E> {
@@ -27,6 +28,7 @@ abstract class BaseLinkedQueuePad0<E> extends AbstractQueue<E> {
     long p30, p31, p32, p33, p34, p35, p36, p37;
 }
 
+@SuppressAnimalSniffer
 abstract class BaseLinkedQueueProducerNodeRef<E> extends BaseLinkedQueuePad0<E> {
     protected final static long P_NODE_OFFSET = UnsafeAccess.addressOf(BaseLinkedQueueProducerNodeRef.class, "producerNode");
 
@@ -50,6 +52,7 @@ abstract class BaseLinkedQueuePad1<E> extends BaseLinkedQueueProducerNodeRef<E>
     long p30, p31, p32, p33, p34, p35, p36, p37;
 }
 
+@SuppressAnimalSniffer
 abstract class BaseLinkedQueueConsumerNodeRef<E> extends BaseLinkedQueuePad1<E> {
     protected final static long C_NODE_OFFSET = UnsafeAccess.addressOf(BaseLinkedQueueConsumerNodeRef.class, "consumerNode");
     protected LinkedQueueNode<E> consumerNode;
@@ -72,8 +75,9 @@ protected final LinkedQueueNode<E> lpConsumerNode() {
  * 
  * @author nitsanw
  * 
- * @param <E>
+ * @param <E> the element type
  */
+@SuppressAnimalSniffer
 abstract class BaseLinkedQueue<E> extends BaseLinkedQueueConsumerNodeRef<E> {
     long p00, p01, p02, p03, p04, p05, p06, p07;
     long p30, p31, p32, p33, p34, p35, p36, p37;
diff --git a/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java b/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
index 06e90da3ea..7a07fc4271 100644
--- a/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
@@ -18,8 +18,9 @@
 
 import static rx.internal.util.unsafe.UnsafeAccess.UNSAFE;
 
-import java.util.AbstractQueue;
-import java.util.Iterator;
+import java.util.*;
+
+import rx.internal.util.SuppressAnimalSniffer;
 
 abstract class ConcurrentCircularArrayQueueL0Pad<E> extends AbstractQueue<E> implements MessagePassingQueue<E> {
     long p00, p01, p02, p03, p04, p05, p06, p07;
@@ -40,8 +41,9 @@ abstract class ConcurrentCircularArrayQueueL0Pad<E> extends AbstractQueue<E> imp
  * 
  * @author nitsanw
  * 
- * @param <E>
+ * @param <E> the element type
  */
+@SuppressAnimalSniffer
 public abstract class ConcurrentCircularArrayQueue<E> extends ConcurrentCircularArrayQueueL0Pad<E> {
     protected static final int SPARSE_SHIFT = Integer.getInteger("sparse.shift", 0);
     protected static final int BUFFER_PAD = 32;
diff --git a/src/main/java/rx/internal/util/unsafe/ConcurrentSequencedCircularArrayQueue.java b/src/main/java/rx/internal/util/unsafe/ConcurrentSequencedCircularArrayQueue.java
index eaf824e95e..1106a4322c 100644
--- a/src/main/java/rx/internal/util/unsafe/ConcurrentSequencedCircularArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/ConcurrentSequencedCircularArrayQueue.java
@@ -18,6 +18,9 @@
 
 import static rx.internal.util.unsafe.UnsafeAccess.UNSAFE;
 
+import rx.internal.util.SuppressAnimalSniffer;
+
+@SuppressAnimalSniffer
 public abstract class ConcurrentSequencedCircularArrayQueue<E> extends ConcurrentCircularArrayQueue<E> {
     private static final long ARRAY_BASE;
     private static final int ELEMENT_SHIFT;
diff --git a/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java b/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java
index a75c2a0028..48ab021d21 100644
--- a/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java
@@ -18,6 +18,8 @@
 
 import static rx.internal.util.unsafe.UnsafeAccess.UNSAFE;
 
+import rx.internal.util.SuppressAnimalSniffer;
+
 abstract class MpmcArrayQueueL1Pad<E> extends ConcurrentSequencedCircularArrayQueue<E> {
     long p10, p11, p12, p13, p14, p15, p16;
     long p30, p31, p32, p33, p34, p35, p36, p37;
@@ -27,6 +29,7 @@ public MpmcArrayQueueL1Pad(int capacity) {
     }
 }
 
+@SuppressAnimalSniffer
 abstract class MpmcArrayQueueProducerField<E> extends MpmcArrayQueueL1Pad<E> {
     private final static long P_INDEX_OFFSET = UnsafeAccess.addressOf(MpmcArrayQueueProducerField.class, "producerIndex");
     private volatile long producerIndex;
@@ -53,6 +56,7 @@ public MpmcArrayQueueL2Pad(int capacity) {
     }
 }
 
+@SuppressAnimalSniffer
 abstract class MpmcArrayQueueConsumerField<E> extends MpmcArrayQueueL2Pad<E> {
     private final static long C_INDEX_OFFSET = UnsafeAccess.addressOf(MpmcArrayQueueConsumerField.class, "consumerIndex");
     private volatile long consumerIndex;
@@ -94,6 +98,7 @@ protected final boolean casConsumerIndex(long expect, long newValue) {
  * @param <E>
  *            type of the element stored in the {@link java.util.Queue}
  */
+@SuppressAnimalSniffer
 public class MpmcArrayQueue<E> extends MpmcArrayQueueConsumerField<E> {
     long p40, p41, p42, p43, p44, p45, p46;
     long p30, p31, p32, p33, p34, p35, p36, p37;
diff --git a/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java b/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
index 11e034e85c..4fd3ab332d 100644
--- a/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
@@ -17,6 +17,8 @@
 package rx.internal.util.unsafe;
 
 import static rx.internal.util.unsafe.UnsafeAccess.UNSAFE;
+
+import rx.internal.util.SuppressAnimalSniffer;
 import rx.internal.util.atomic.LinkedQueueNode;
 /**
  * This is a direct Java port of the MPSC algorithm as presented <a
@@ -34,6 +36,7 @@
  * 
  * @param <E>
  */
+@SuppressAnimalSniffer
 public final class MpscLinkedQueue<E> extends BaseLinkedQueue<E> {
     
     public MpscLinkedQueue() {
diff --git a/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
index cdd029ade1..881eeb242b 100644
--- a/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
@@ -18,6 +18,8 @@
 
 import static rx.internal.util.unsafe.UnsafeAccess.UNSAFE;
 
+import rx.internal.util.SuppressAnimalSniffer;
+
 abstract class SpmcArrayQueueL1Pad<E> extends ConcurrentCircularArrayQueue<E> {
     long p10, p11, p12, p13, p14, p15, p16;
     long p30, p31, p32, p33, p34, p35, p36, p37;
@@ -27,6 +29,7 @@ public SpmcArrayQueueL1Pad(int capacity) {
     }
 }
 
+@SuppressAnimalSniffer
 abstract class SpmcArrayQueueProducerField<E> extends SpmcArrayQueueL1Pad<E> {
     protected final static long P_INDEX_OFFSET = UnsafeAccess.addressOf(SpmcArrayQueueProducerField.class, "producerIndex");
     private volatile long producerIndex;
@@ -53,6 +56,7 @@ public SpmcArrayQueueL2Pad(int capacity) {
     }
 }
 
+@SuppressAnimalSniffer
 abstract class SpmcArrayQueueConsumerField<E> extends SpmcArrayQueueL2Pad<E> {
     protected final static long C_INDEX_OFFSET = UnsafeAccess.addressOf(SpmcArrayQueueConsumerField.class, "consumerIndex");
     private volatile long consumerIndex;
@@ -79,6 +83,7 @@ public SpmcArrayQueueMidPad(int capacity) {
     }
 }
 
+@SuppressAnimalSniffer
 abstract class SpmcArrayQueueProducerIndexCacheField<E> extends SpmcArrayQueueMidPad<E> {
     // This is separated from the consumerIndex which will be highly contended in the hope that this value spends most
     // of it's time in a cache line that is Shared(and rarely invalidated)
@@ -106,6 +111,7 @@ public SpmcArrayQueueL3Pad(int capacity) {
     }
 }
 
+@SuppressAnimalSniffer
 public final class SpmcArrayQueue<E> extends SpmcArrayQueueL3Pad<E> {
 
     public SpmcArrayQueue(final int capacity) {
diff --git a/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
index ae9a5b771a..549c6da02c 100644
--- a/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
@@ -18,6 +18,8 @@
 
 import static rx.internal.util.unsafe.UnsafeAccess.UNSAFE;
 
+import rx.internal.util.SuppressAnimalSniffer;
+
 abstract class SpscArrayQueueColdField<E> extends ConcurrentCircularArrayQueue<E> {
     private static final Integer MAX_LOOK_AHEAD_STEP = Integer.getInteger("jctools.spsc.max.lookahead.step", 4096);
     protected final int lookAheadStep;
@@ -35,6 +37,7 @@ public SpscArrayQueueL1Pad(int capacity) {
     }
 }
 
+@SuppressAnimalSniffer
 abstract class SpscArrayQueueProducerFields<E> extends SpscArrayQueueL1Pad<E> {
     protected final static long P_INDEX_OFFSET = UnsafeAccess.addressOf(SpscArrayQueueProducerFields.class, "producerIndex");
     protected long producerIndex;
@@ -54,6 +57,7 @@ public SpscArrayQueueL2Pad(int capacity) {
     }
 }
 
+@SuppressAnimalSniffer
 abstract class SpscArrayQueueConsumerField<E> extends SpscArrayQueueL2Pad<E> {
     protected long consumerIndex;
     protected final static long C_INDEX_OFFSET = UnsafeAccess.addressOf(SpscArrayQueueConsumerField.class, "consumerIndex");
@@ -87,6 +91,7 @@ public SpscArrayQueueL3Pad(int capacity) {
  * 
  * @param <E>
  */
+@SuppressAnimalSniffer
 public final class SpscArrayQueue<E> extends SpscArrayQueueL3Pad<E> {
 
     public SpscArrayQueue(final int capacity) {
diff --git a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
index dc353e0ae7..271ce07dc1 100644
--- a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
@@ -22,6 +22,8 @@
 import java.util.AbstractQueue;
 import java.util.Iterator;
 
+import rx.internal.util.SuppressAnimalSniffer;
+
 abstract class SpscUnboundedArrayQueueProducerFields<E> extends AbstractQueue<E> {
     protected long producerIndex;
 }
@@ -46,6 +48,7 @@ abstract class SpscUnboundedArrayQueueConsumerField<E> extends SpscUnboundedArra
     protected long consumerIndex;
 }
 
+@SuppressAnimalSniffer
 public class SpscUnboundedArrayQueue<E> extends SpscUnboundedArrayQueueConsumerField<E>
     implements QueueProgressIndicators{
     static final int MAX_LOOK_AHEAD_STEP = Integer.getInteger("jctools.spsc.max.lookahead.step", 4096);
diff --git a/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java b/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
index fd3fd447a2..d45d5d4946 100644
--- a/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
+++ b/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
@@ -17,6 +17,7 @@
 
 import java.lang.reflect.Field;
 
+import rx.internal.util.SuppressAnimalSniffer;
 import sun.misc.Unsafe;
 
 /**
@@ -26,6 +27,7 @@
  * Note that you can force RxJava to not use Unsafe API by setting any value to System Property
  * {@code rx.unsafe-disable}.
  */
+@SuppressAnimalSniffer
 public final class UnsafeAccess {
 
     public static final Unsafe UNSAFE;
diff --git a/src/test/java/rx/internal/operators/OperatorMapPairTest.java b/src/test/java/rx/internal/operators/OperatorMapPairTest.java
index 2554b5e2f3..7460496525 100644
--- a/src/test/java/rx/internal/operators/OperatorMapPairTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMapPairTest.java
@@ -1,3 +1,18 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
 
 import org.junit.*;
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchTest.java b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
index a908ec10cf..94c5ae236a 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
@@ -873,7 +873,9 @@ public void call(Throwable e) {
             
             ts.awaitTerminalEvent(60, TimeUnit.SECONDS);
             if (!q.isEmpty()) {
-                throw new AssertionError("Dropped exceptions", new CompositeException(q));
+                AssertionError ae = new AssertionError("Dropped exceptions");
+                ae.initCause(new CompositeException(q));
+                throw ae;
             }
             ts.assertNoErrors();
             if (ts.getCompletions() == 0) {
diff --git a/src/test/java/rx/observers/TestSubscriberTest.java b/src/test/java/rx/observers/TestSubscriberTest.java
index 776f48367c..f5d1146c14 100644
--- a/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/src/test/java/rx/observers/TestSubscriberTest.java
@@ -590,7 +590,7 @@ public void onNext(Integer t) {
         ts.awaitTerminalEvent();
     }
     
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void testOnErrorCrashCountsDownLatch() {
         Observer<Integer> to = new Observer<Integer>() {
             @Override
diff --git a/src/test/java/rx/plugins/RxJavaPluginsTest.java b/src/test/java/rx/plugins/RxJavaPluginsTest.java
index b4171ea11a..b8a1a13bf7 100644
--- a/src/test/java/rx/plugins/RxJavaPluginsTest.java
+++ b/src/test/java/rx/plugins/RxJavaPluginsTest.java
@@ -232,7 +232,7 @@ public Date call(Date date) {
                                                  throw new IllegalStateException("Trigger OnNextValue");
                                              }
                                          })
-                                         .timeout(500, TimeUnit.MILLISECONDS)
+                                         .timeout(5000, TimeUnit.MILLISECONDS)
                                          .toBlocking().first();
             fail("Did not expect onNext/onCompleted, got " + notExpected);
         } catch (IllegalStateException e) {
diff --git a/src/test/java/rx/schedulers/ResetSchedulersTest.java b/src/test/java/rx/schedulers/ResetSchedulersTest.java
index 2fc2c4eaa4..fc06c6c5f5 100644
--- a/src/test/java/rx/schedulers/ResetSchedulersTest.java
+++ b/src/test/java/rx/schedulers/ResetSchedulersTest.java
@@ -1,3 +1,18 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.schedulers;
 
 
diff --git a/src/test/java/rx/subjects/BehaviorSubjectTest.java b/src/test/java/rx/subjects/BehaviorSubjectTest.java
index bc71fd212a..5b201814d5 100644
--- a/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -240,7 +240,7 @@ public void testCompletedAfterErrorIsNotSent3() {
         verify(o2, times(1)).onCompleted();
         verifyNoMoreInteractions(o2);
     }
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void testUnsubscriptionCase() {
         BehaviorSubject<String> src = BehaviorSubject.create((String)null);
         
diff --git a/src/test/java/rx/subjects/PublishSubjectTest.java b/src/test/java/rx/subjects/PublishSubjectTest.java
index 93c9be4bd3..4dd974837a 100644
--- a/src/test/java/rx/subjects/PublishSubjectTest.java
+++ b/src/test/java/rx/subjects/PublishSubjectTest.java
@@ -332,7 +332,7 @@ public void testReSubscribe() {
 
     private final Throwable testException = new Throwable();
 
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void testUnsubscriptionCase() {
         PublishSubject<String> src = PublishSubject.create();
 
diff --git a/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java b/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
index 1c29ee6348..fa0b5e5764 100644
--- a/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
@@ -154,7 +154,7 @@ public void onNext(Long args) {
         slowThread.join();
     }
 
-    @Test
+//    @Test
     public void unboundedReplaySubjectConcurrentSubscriptionsLoop() throws Exception {
         for (int i = 0; i < 50; i++) {
             System.out.println(i + " --------------------------------------------------------------- ");
@@ -169,7 +169,7 @@ public void unboundedReplaySubjectConcurrentSubscriptions() throws InterruptedEx
         ReplaySubjectConcurrencyTest.concurrencyTest(replay);
     }
 
-    @Test
+//    @Test
     public void unboundedTimeReplaySubjectConcurrentSubscriptionsLoop() throws Exception {
         for (int i = 0; i < 50; i++) {
             System.out.println(i + " --------------------------------------------------------------- ");
diff --git a/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java b/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
index 14e57537d5..97fea6898b 100644
--- a/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
@@ -154,7 +154,7 @@ public void onNext(Long args) {
         slowThread.join();
     }
 
-    @Test
+//    @Test
     public void testReplaySubjectConcurrentSubscriptionsLoop() throws Exception {
         for (int i = 0; i < 50; i++) {
             System.out.println(i + " --------------------------------------------------------------- ");
diff --git a/src/test/java/rx/subjects/ReplaySubjectTest.java b/src/test/java/rx/subjects/ReplaySubjectTest.java
index 7d5b5b8785..50e1702869 100644
--- a/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -368,7 +368,7 @@ public void testSubscriptionLeak() {
         
         assertEquals(0, replaySubject.subscriberCount());
     }
-    @Test(timeout = 1000)
+    @Test(timeout = 5000)
     public void testUnsubscriptionCase() {
         ReplaySubject<String> src = ReplaySubject.create();
         

From c60a08bc907747b871b522104fec20ebec36bcae Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 25 Jun 2016 08:07:21 +0200
Subject: [PATCH 081/263] 1.x: exclude some text files from license checks
 (#4093)

---
 build.gradle | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/build.gradle b/build.gradle
index 0221350605..39a1b0db60 100644
--- a/build.gradle
+++ b/build.gradle
@@ -61,6 +61,10 @@ test{
      maxHeapSize = "2g"
 }
 
+license {
+    excludes(["**/*.md", "**/*.txt", "**/unsafe/*.java", "**/atomic/*.java", "**/Beta.java", "**/Experimental.java"])
+}
+
 jacoco {
     toolVersion = '0.7.7.201606060606' // See http://www.eclemma.org/jacoco/.
 }

From c110f695ec439191d653ad800fd24e90d69b0832 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 25 Jun 2016 08:07:44 +0200
Subject: [PATCH 082/263] 1.x: update map() and filter() to implement
 OnSubscribe directly (#4097)

---
 src/main/java/rx/Observable.java              |  4 +-
 src/main/java/rx/Single.java                  |  2 +-
 ...atorFilter.java => OnSubscribeFilter.java} | 13 +--
 .../{OperatorMap.java => OnSubscribeMap.java} | 15 ++--
 .../operators/SingleOnSubscribeMap.java       | 90 +++++++++++++++++++
 .../java/rx/operators/OperatorMapPerf.java    | 15 +---
 .../java/rx/ObservableConversionTest.java     |  8 +-
 .../internal/operators/OperatorMapTest.java   |  8 +-
 8 files changed, 120 insertions(+), 35 deletions(-)
 rename src/main/java/rx/internal/operators/{OperatorFilter.java => OnSubscribeFilter.java} (88%)
 rename src/main/java/rx/internal/operators/{OperatorMap.java => OnSubscribeMap.java} (88%)
 create mode 100644 src/main/java/rx/internal/operators/SingleOnSubscribeMap.java

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 4599edb5f4..4205a71d9e 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -5816,7 +5816,7 @@ public final Observable<Boolean> exists(Func1<? super T, Boolean> predicate) {
      * @see <a href="http://reactivex.io/documentation/operators/filter.html">ReactiveX operators documentation: Filter</a>
      */
     public final Observable<T> filter(Func1<? super T, Boolean> predicate) {
-        return lift(new OperatorFilter<T>(predicate));
+        return create(new OnSubscribeFilter<T>(this, predicate));
     }
 
     /**
@@ -6623,7 +6623,7 @@ public final Observable<T> limit(int count) {
      * @see <a href="http://reactivex.io/documentation/operators/map.html">ReactiveX operators documentation: Map</a>
      */
     public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
-        return lift(new OperatorMap<T, R>(func));
+        return create(new OnSubscribeMap<T, R>(this, func));
     }
     
     private <R> Observable<R> mapNotification(Func1<? super T, ? extends R> onNext, Func1<? super Throwable, ? extends R> onError, Func0<? extends R> onCompleted) {
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index c4c4e71881..3fa4cc39ac 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -1413,7 +1413,7 @@ public final <R> Observable<R> flatMapObservable(Func1<? super T, ? extends Obse
      * @see <a href="http://reactivex.io/documentation/operators/map.html">ReactiveX operators documentation: Map</a>
      */
     public final <R> Single<R> map(Func1<? super T, ? extends R> func) {
-        return lift(new OperatorMap<T, R>(func));
+        return create(new SingleOnSubscribeMap<T, R>(this, func));
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/OperatorFilter.java b/src/main/java/rx/internal/operators/OnSubscribeFilter.java
similarity index 88%
rename from src/main/java/rx/internal/operators/OperatorFilter.java
rename to src/main/java/rx/internal/operators/OnSubscribeFilter.java
index 6d489b0e67..2fe3abcde0 100644
--- a/src/main/java/rx/internal/operators/OperatorFilter.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFilter.java
@@ -16,7 +16,7 @@
 package rx.internal.operators;
 
 import rx.*;
-import rx.Observable.Operator;
+import rx.Observable.OnSubscribe;
 import rx.exceptions.*;
 import rx.functions.Func1;
 import rx.internal.util.RxJavaPluginUtils;
@@ -27,19 +27,22 @@
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/filter.png" alt="">
  * @param <T> the value type
  */
-public final class OperatorFilter<T> implements Operator<T, T> {
+public final class OnSubscribeFilter<T> implements OnSubscribe<T> {
 
+    final Observable<T> source;
+    
     final Func1<? super T, Boolean> predicate;
 
-    public OperatorFilter(Func1<? super T, Boolean> predicate) {
+    public OnSubscribeFilter(Observable<T> source, Func1<? super T, Boolean> predicate) {
+        this.source = source;
         this.predicate = predicate;
     }
 
     @Override
-    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+    public void call(final Subscriber<? super T> child) {
         FilterSubscriber<T> parent = new FilterSubscriber<T>(child, predicate);
         child.add(parent);
-        return parent;
+        source.unsafeSubscribe(parent);
     }
 
     static final class FilterSubscriber<T> extends Subscriber<T> {
diff --git a/src/main/java/rx/internal/operators/OperatorMap.java b/src/main/java/rx/internal/operators/OnSubscribeMap.java
similarity index 88%
rename from src/main/java/rx/internal/operators/OperatorMap.java
rename to src/main/java/rx/internal/operators/OnSubscribeMap.java
index a8a33178ca..0ad3ea39e8 100644
--- a/src/main/java/rx/internal/operators/OperatorMap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeMap.java
@@ -16,7 +16,7 @@
 package rx.internal.operators;
 
 import rx.*;
-import rx.Observable.Operator;
+import rx.Observable.OnSubscribe;
 import rx.exceptions.*;
 import rx.functions.Func1;
 import rx.internal.util.RxJavaPluginUtils;
@@ -30,19 +30,22 @@
  * @param <T> the input value type
  * @param <R> the return value type
  */
-public final class OperatorMap<T, R> implements Operator<R, T> {
+public final class OnSubscribeMap<T, R> implements OnSubscribe<R> {
 
+    final Observable<T> source;
+    
     final Func1<? super T, ? extends R> transformer;
 
-    public OperatorMap(Func1<? super T, ? extends R> transformer) {
+    public OnSubscribeMap(Observable<T> source, Func1<? super T, ? extends R> transformer) {
+        this.source = source;
         this.transformer = transformer;
     }
-
+    
     @Override
-    public Subscriber<? super T> call(final Subscriber<? super R> o) {
+    public void call(final Subscriber<? super R> o) {
         MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
         o.add(parent);
-        return parent;
+        source.unsafeSubscribe(parent);
     }
     
     static final class MapSubscriber<T, R> extends Subscriber<T> {
diff --git a/src/main/java/rx/internal/operators/SingleOnSubscribeMap.java b/src/main/java/rx/internal/operators/SingleOnSubscribeMap.java
new file mode 100644
index 0000000000..78ff4936ff
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleOnSubscribeMap.java
@@ -0,0 +1,90 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.exceptions.*;
+import rx.functions.Func1;
+import rx.internal.util.RxJavaPluginUtils;
+
+/**
+ * Applies a function of your choosing to every item emitted by an {@code Single}, and emits the results of
+ * this transformation as a new {@code Single}.
+ * 
+ * @param <T> the input value type
+ * @param <R> the return value type
+ */
+public final class SingleOnSubscribeMap<T, R> implements Single.OnSubscribe<R> {
+
+    final Single<T> source;
+    
+    final Func1<? super T, ? extends R> transformer;
+
+    public SingleOnSubscribeMap(Single<T> source, Func1<? super T, ? extends R> transformer) {
+        this.source = source;
+        this.transformer = transformer;
+    }
+    
+    @Override
+    public void call(final SingleSubscriber<? super R> o) {
+        MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
+        o.add(parent);
+        source.subscribe(parent);
+    }
+    
+    static final class MapSubscriber<T, R> extends SingleSubscriber<T> {
+        
+        final SingleSubscriber<? super R> actual;
+        
+        final Func1<? super T, ? extends R> mapper;
+
+        boolean done;
+        
+        public MapSubscriber(SingleSubscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
+            this.actual = actual;
+            this.mapper = mapper;
+        }
+        
+        @Override
+        public void onSuccess(T t) {
+            R result;
+            
+            try {
+                result = mapper.call(t);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                onError(OnErrorThrowable.addValueAsLastCause(ex, t));
+                return;
+            }
+            
+            actual.onSuccess(result);
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            if (done) {
+                RxJavaPluginUtils.handleException(e);
+                return;
+            }
+            done = true;
+            
+            actual.onError(e);
+        }
+    }
+
+}
+
diff --git a/src/perf/java/rx/operators/OperatorMapPerf.java b/src/perf/java/rx/operators/OperatorMapPerf.java
index 124aee65e4..81ee0ae702 100644
--- a/src/perf/java/rx/operators/OperatorMapPerf.java
+++ b/src/perf/java/rx/operators/OperatorMapPerf.java
@@ -17,17 +17,9 @@
 
 import java.util.concurrent.TimeUnit;
 
-import org.openjdk.jmh.annotations.BenchmarkMode;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.Mode;
-import org.openjdk.jmh.annotations.OutputTimeUnit;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.*;
 
-import rx.Observable.Operator;
 import rx.functions.Func1;
-import rx.internal.operators.OperatorMap;
 import rx.jmh.InputWithIncrementingInteger;
 
 @BenchmarkMode(Mode.Throughput)
@@ -49,7 +41,7 @@ public int getSize() {
 
     @Benchmark
     public void mapPassThruViaLift(Input input) throws InterruptedException {
-        input.observable.lift(MAP_OPERATOR).subscribe(input.observer);
+        input.observable.map(IDENTITY_FUNCTION).subscribe(input.observer);
     }
 
     @Benchmark
@@ -63,7 +55,4 @@ public Integer call(Integer value) {
             return value;
         }
     };
-
-    private static final Operator<Integer, Integer> MAP_OPERATOR = new OperatorMap<Integer, Integer>(IDENTITY_FUNCTION);
-
 }
diff --git a/src/test/java/rx/ObservableConversionTest.java b/src/test/java/rx/ObservableConversionTest.java
index 56f3ee2cd5..b90132fed7 100644
--- a/src/test/java/rx/ObservableConversionTest.java
+++ b/src/test/java/rx/ObservableConversionTest.java
@@ -31,8 +31,8 @@
 import rx.exceptions.OnErrorNotImplementedException;
 import rx.functions.Func1;
 import rx.functions.Func2;
-import rx.internal.operators.OperatorFilter;
-import rx.internal.operators.OperatorMap;
+import rx.internal.operators.OnSubscribeFilter;
+import rx.internal.operators.OnSubscribeMap;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 
@@ -76,11 +76,11 @@ public <R> CylonDetectorObservable<? extends R> compose(Func1<CylonDetectorObser
         }
         
         public final CylonDetectorObservable<T> beep(Func1<? super T, Boolean> predicate) {
-            return lift(new OperatorFilter<T>(predicate));
+            return create(new OnSubscribeFilter<T>(Observable.create(onSubscribe), predicate));
         }
         
         public final <R> CylonDetectorObservable<R> boop(Func1<? super T, ? extends R> func) {
-            return lift(new OperatorMap<T, R>(func));
+            return create(new OnSubscribeMap<T, R>(Observable.create(onSubscribe), func));
         }
 
         public CylonDetectorObservable<String> DESTROY() {
diff --git a/src/test/java/rx/internal/operators/OperatorMapTest.java b/src/test/java/rx/internal/operators/OperatorMapTest.java
index 18e3e523e3..d13439b5de 100644
--- a/src/test/java/rx/internal/operators/OperatorMapTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMapTest.java
@@ -57,14 +57,14 @@ public void testMap() {
         Map<String, String> m2 = getMap("Two");
         Observable<Map<String, String>> observable = Observable.just(m1, m2);
 
-        Observable<String> m = observable.lift(new OperatorMap<Map<String, String>, String>(new Func1<Map<String, String>, String>() {
+        Observable<String> m = observable.map(new Func1<Map<String, String>, String>() {
 
             @Override
             public String call(Map<String, String> map) {
                 return map.get("firstName");
             }
 
-        }));
+        });
         m.subscribe(stringObserver);
 
         verify(stringObserver, never()).onError(any(Throwable.class));
@@ -155,7 +155,7 @@ public String call(Map<String, String> map) {
     @Test
     public void testMapWithError() {
         Observable<String> w = Observable.just("one", "fail", "two", "three", "fail");
-        Observable<String> m = w.lift(new OperatorMap<String, String>(new Func1<String, String>() {
+        Observable<String> m = w.map(new Func1<String, String>() {
             @Override
             public String call(String s) {
                 if ("fail".equals(s)) {
@@ -163,7 +163,7 @@ public String call(String s) {
                 }
                 return s;
             }
-        })).doOnError(new Action1<Throwable>() {
+        }).doOnError(new Action1<Throwable>() {
 
             @Override
             public void call(Throwable t1) {

From d855a292d6afcb754d664bff475fd40c30776171 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Sat, 25 Jun 2016 19:46:49 +1000
Subject: [PATCH 083/263] add groupBy overload with evictingMapFactory (#3931)

---
 build.gradle                                  |   1 +
 src/main/java/rx/Observable.java              |  59 +++++
 .../internal/operators/OperatorGroupBy.java   |  79 ++++++-
 .../operators/OperatorGroupByTest.java        | 215 +++++++++++++++++-
 4 files changed, 344 insertions(+), 10 deletions(-)

diff --git a/build.gradle b/build.gradle
index 39a1b0db60..98d087ba40 100644
--- a/build.gradle
+++ b/build.gradle
@@ -25,6 +25,7 @@ dependencies {
 
     testCompile 'junit:junit:4.12'
     testCompile 'org.mockito:mockito-core:1.10.19'
+    testCompile 'com.google.guava:guava:19.0'
 
     perfCompile 'org.openjdk.jmh:jmh-core:1.11.3'
     perfCompile 'org.openjdk.jmh:jmh-generator-annprocess:1.11.3'
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 4205a71d9e..e3111e31ec 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -6356,6 +6356,65 @@ public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? su
         return lift(new OperatorGroupBy<T, K, R>(keySelector, elementSelector));
     }
     
+    /**
+     * Groups the items emitted by an {@code Observable} according to a specified criterion, and emits these
+     * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservable} allows only a single 
+     * {@link Subscriber} during its lifetime and if this {@code Subscriber} unsubscribes before the 
+     * source terminates, the next emission by the source having the same key will trigger a new 
+     * {@code GroupedObservable} emission.
+     * <p>
+     * <img width="640" height="360" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/groupBy.png" alt="">
+     * <p>
+     * <em>Note:</em> A {@link GroupedObservable} will cache the items it is to emit until such time as it
+     * is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those
+     * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may
+     * discard their buffers by applying an operator like {@link #ignoreElements} to them.
+     * <dl>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code groupBy} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * 
+     * @param keySelector
+     *            a function that extracts the key for each item
+     * @param elementSelector
+     *            a function that extracts the return element for each item
+     * @param evictingMapFactory
+     *            a function that given an eviction action returns a {@link Map} instance that will be used to assign 
+     *            items to the appropriate {@code GroupedObservable}s. The {@code Map} instance must be thread-safe 
+     *            and any eviction must trigger a call to the supplied action (synchronously or asynchronously). 
+     *            This can be used to limit the size of the map by evicting keys by maximum size or access time for 
+     *            instance. Here's an example using Guava's {@code CacheBuilder} from v19.0:
+     *            <pre>
+     *            {@code
+     *            Func1<Action1<K>, Map<K, Object>> mapFactory 
+     *              = action -> CacheBuilder.newBuilder()
+     *                  .maximumSize(1000)
+     *                  .expireAfterAccess(12, TimeUnit.HOURS)
+     *                  .removalListener(notification -> action.call(notification.getKey()))
+     *                  .<K, Object> build().asMap();
+     *            }
+     *            </pre>
+     *            
+     * @param <K>
+     *            the key type
+     * @param <R>
+     *            the element type
+     * @return an {@code Observable} that emits {@link GroupedObservable}s, each of which corresponds to a
+     *         unique key value and each of which emits those items from the source Observable that share that
+     *         key value
+     * @throws NullPointerException
+     *             if {@code evictingMapFactory} is null
+     * @see <a href="http://reactivex.io/documentation/operators/groupby.html">ReactiveX operators documentation: GroupBy</a>
+     */
+    @Experimental
+    public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? super T, ? extends K> keySelector, 
+            final Func1<? super T, ? extends R> elementSelector, final Func1<Action1<K>, Map<K, Object>> evictingMapFactory) {
+        if (evictingMapFactory == null) {
+            throw new NullPointerException("evictingMapFactory cannot be null");
+        }
+        return lift(new OperatorGroupBy<T, K, R>(keySelector, elementSelector, evictingMapFactory));
+    }
+    
     /**
      * Groups the items emitted by an {@code Observable} according to a specified criterion, and emits these
      * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservable} allows only a single 
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index 954b1ac6c5..b6c2e08bd1 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -21,11 +21,13 @@
 
 import rx.*;
 import rx.Observable.*;
+import rx.exceptions.Exceptions;
 import rx.functions.*;
 import rx.internal.producers.ProducerArbiter;
 import rx.internal.util.*;
 import rx.observables.GroupedObservable;
 import rx.plugins.RxJavaHooks;
+import rx.observers.Subscribers;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -46,35 +48,50 @@ public final class OperatorGroupBy<T, K, V> implements Operator<GroupedObservabl
     final Func1<? super T, ? extends V> valueSelector;
     final int bufferSize;
     final boolean delayError;
+    final Func1<Action1<K>, Map<K, Object>> mapFactory; //nullable
     
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public OperatorGroupBy(Func1<? super T, ? extends K> keySelector) {
-        this(keySelector, (Func1)UtilityFunctions.<T>identity(), RxRingBuffer.SIZE, false);
+        this(keySelector, (Func1)UtilityFunctions.<T>identity(), RxRingBuffer.SIZE, false, null);
     }
 
     public OperatorGroupBy(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
-        this(keySelector, valueSelector, RxRingBuffer.SIZE, false);
+        this(keySelector, valueSelector, RxRingBuffer.SIZE, false, null);
+    }
+    
+    public OperatorGroupBy(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func1<Action1<K>, Map<K, Object>> mapFactory) {
+        this(keySelector, valueSelector, RxRingBuffer.SIZE, false, mapFactory);
     }
 
-    public OperatorGroupBy(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError) {
+    public OperatorGroupBy(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError, Func1<Action1<K>, Map<K, Object>> mapFactory) {
         this.keySelector = keySelector;
         this.valueSelector = valueSelector;
         this.bufferSize = bufferSize;
         this.delayError = delayError;
+        this.mapFactory = mapFactory;
     }
     
     @Override
-    public Subscriber<? super T> call(Subscriber<? super GroupedObservable<K, V>> t) {
-        final GroupBySubscriber<T, K, V> parent = new GroupBySubscriber<T, K, V>(t, keySelector, valueSelector, bufferSize, delayError);
+    public Subscriber<? super T> call(Subscriber<? super GroupedObservable<K, V>> child) {
+        final GroupBySubscriber<T, K, V> parent;
+        try {
+            parent = new GroupBySubscriber<T, K, V>(child, keySelector, valueSelector, bufferSize, delayError, mapFactory);
+        } catch (Throwable ex) {
+            //Can reach here because mapFactory.call() may throw in constructor of GroupBySubscriber
+            Exceptions.throwOrReport(ex, child);
+            Subscriber<? super T> parent2 = Subscribers.empty();
+            parent2.unsubscribe();
+            return parent2;
+        }
 
-        t.add(Subscriptions.create(new Action0() {
+        child.add(Subscriptions.create(new Action0() {
             @Override
             public void call() {
                 parent.cancel();
             }
         }));
 
-        t.setProducer(parent.producer);
+        child.setProducer(parent.producer);
         
         return parent;
     }
@@ -101,6 +118,7 @@ public static final class GroupBySubscriber<T, K, V>
         final Map<Object, GroupedUnicast<K, V>> groups;
         final Queue<GroupedObservable<K, V>> queue;
         final GroupByProducer producer;
+        final Queue<K> evictedKeys;
         
         static final Object NULL_KEY = new Object();
         
@@ -117,13 +135,14 @@ public static final class GroupBySubscriber<T, K, V>
 
         final AtomicInteger wip;
         
-        public GroupBySubscriber(Subscriber<? super GroupedObservable<K, V>> actual, Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError) {
+        public GroupBySubscriber(Subscriber<? super GroupedObservable<K, V>> actual, Func1<? super T, ? extends K> keySelector, 
+                Func1<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError, 
+                Func1<Action1<K>, Map<K, Object>> mapFactory) {
             this.actual = actual;
             this.keySelector = keySelector;
             this.valueSelector = valueSelector;
             this.bufferSize = bufferSize;
             this.delayError = delayError;
-            this.groups = new ConcurrentHashMap<Object, GroupedUnicast<K, V>>();
             this.queue = new ConcurrentLinkedQueue<GroupedObservable<K, V>>();
             this.s = new ProducerArbiter();
             this.s.request(bufferSize);
@@ -132,6 +151,32 @@ public GroupBySubscriber(Subscriber<? super GroupedObservable<K, V>> actual, Fun
             this.requested = new AtomicLong();
             this.groupCount = new AtomicInteger(1);
             this.wip = new AtomicInteger();
+            if (mapFactory == null) {
+                this.groups = new ConcurrentHashMap<Object, GroupedUnicast<K, V>>();
+                this.evictedKeys = null;
+            } else {
+                this.evictedKeys = new ConcurrentLinkedQueue<K>();
+                this.groups = createMap(mapFactory, new EvictionAction<K>(evictedKeys));
+            }
+        }
+        
+        static class EvictionAction<K> implements Action1<K> {
+
+            final Queue<K> evictedKeys;
+
+            EvictionAction(Queue<K> evictedKeys) {
+                this.evictedKeys = evictedKeys;
+            }
+            
+            @Override
+            public void call(K key) {
+                evictedKeys.offer(key);
+            }
+        }
+        
+        @SuppressWarnings("unchecked")
+        private Map<Object, GroupedUnicast<K, V>> createMap(Func1<Action1<K>, Map<K, Object>> mapFactory, Action1<K> evictionAction) {
+            return (Map<Object, GroupedUnicast<K,V>>)(Map<Object, ?>) mapFactory.call(evictionAction);
         }
         
         @Override
@@ -187,6 +232,16 @@ public void onNext(T t) {
             }
 
             group.onNext(v);
+            
+            if (evictedKeys != null) {
+                K evictedKey;
+                while ((evictedKey = evictedKeys.poll()) != null) {
+                    GroupedUnicast<K, V> g = groups.get(evictedKey);
+                    if (g != null) {
+                        g.onComplete();
+                    }
+                }
+            }
 
             if (notNew) {
                 s.request(1);
@@ -215,6 +270,9 @@ public void onCompleted() {
                 e.onComplete();
             }
             groups.clear();
+            if (evictedKeys != null) {
+                evictedKeys.clear();
+            }
 
             done = true;
             groupCount.decrementAndGet();
@@ -306,6 +364,9 @@ void errorAll(Subscriber<? super GroupedObservable<K, V>> a, Queue<?> q, Throwab
             q.clear();
             List<GroupedUnicast<K, V>> list = new ArrayList<GroupedUnicast<K, V>>(groups.values());
             groups.clear();
+            if (evictedKeys != null) { 
+                evictedKeys.clear();
+            }
             
             for (GroupedUnicast<K, V> e : list) {
                 e.onError(ex);
diff --git a/src/test/java/rx/internal/operators/OperatorGroupByTest.java b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
index 438595416f..c137bcc8f2 100644
--- a/src/test/java/rx/internal/operators/OperatorGroupByTest.java
+++ b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
@@ -26,10 +26,15 @@
 import org.junit.*;
 import org.mockito.*;
 
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.RemovalListener;
+import com.google.common.cache.RemovalNotification;
+
 import rx.*;
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
+import rx.exceptions.OnErrorNotImplementedException;
 import rx.exceptions.TestException;
 import rx.functions.*;
 import rx.internal.util.*;
@@ -1243,7 +1248,7 @@ public void testError2() {
     }
 
     @Test
-    public void testgroupByBackpressure() throws InterruptedException {
+    public void testGroupByBackpressure2() throws InterruptedException {
         TestSubscriber<String> ts = new TestSubscriber<String>();
 
         Observable.range(1, 4000).groupBy(IS_EVEN2).flatMap(new Func1<GroupedObservable<Boolean, Integer>, Observable<String>>() {
@@ -1804,4 +1809,212 @@ public Integer call(Integer pair) {
         outer.assertValueCount(2);
 
     }
+    
+    @Test
+    public void mapFactoryEvictionWorks() {
+        Func1<Integer, Integer> keySelector = new Func1<Integer, Integer> (){
+            @Override
+            public Integer call(Integer t) {
+                return t /10;
+            }};
+        Func1<Integer, Integer> elementSelector = UtilityFunctions.identity();
+        final List<Integer> evictedKeys = new ArrayList<Integer>();
+        //normally would use Guava CacheBuilder or similar but for a bit more 
+        //control make something custom
+        Func1<Action1<Integer>, Map<Integer, Object>> mapFactory = new Func1<Action1<Integer>, Map<Integer, Object>>() {
+            @Override
+            public Map<Integer, Object> call(final Action1<Integer> evicted) {
+                // is a bit risky to override the put method because 
+                // of possible side-effects (e.g. remove could call put and we did not know it)
+                // to fix just need to use composition but needs a verbose implementation of Map
+                // interface
+                return new ConcurrentHashMap<Integer,Object>() {
+                    private static final long serialVersionUID = -7519109652858021153L;
+                    
+                    Integer lastKey = null;
+                    
+                    @Override
+                    public Object put(Integer key, Object value) {
+                        if (this.size() >= 5) {
+                            super.remove(lastKey);
+                            evicted.call(lastKey);
+                            evictedKeys.add(lastKey);
+                        }
+                        Object result = super.put(key, value);
+                        lastKey = key;
+                        return result;
+                    }};
+            }};
+        TestSubscriber<String> ts = TestSubscriber.create();
+        Observable
+            .range(1, 100)
+            .groupBy(keySelector,elementSelector, mapFactory)
+            .flatMap(new Func1<GroupedObservable<Integer, Integer>, Observable<String>>() {
+                @Override
+                public Observable<String> call(final GroupedObservable<Integer, Integer> g) {
+                    return g.map(new Func1<Integer, String>() {
+                        @Override
+                        public String call(Integer x) {
+                            return g.getKey() + ":" + x;
+                        }
+                    });
+                }
+            })
+            .subscribe(ts);
+        assertEquals(Arrays.asList(4, 5, 6, 7, 8, 9), evictedKeys);
+        List<String> expected = Observable
+                .range(1, 100)
+                .map(new Func1<Integer, String>() {
+                        @Override
+                        public String call(Integer x) {
+                            return (x /10) + ":" + x;
+                        }
+                    })
+                .toList().toBlocking().single();
+        assertEquals(expected, ts.getOnNextEvents());
+    }
+    
+    private static final Func1<Integer, Integer> EVICTING_MAP_ELEMENT_SELECTOR = UtilityFunctions.identity();
+    
+    private static final Func1<Integer, Integer> EVICTING_MAP_KEY_SELECTOR = new Func1<Integer, Integer> (){
+        @Override
+        public Integer call(Integer t) {
+            return t /10;
+        }};
+    
+    @Test
+    public void testEvictingMapFactoryIfMapPutThrowsRuntimeExceptionThenErrorEmittedByStream() {
+        final RuntimeException exception = new RuntimeException("boo");
+        Func1<Action1<Integer>, Map<Integer, Object>> mapFactory = createMapFactoryThatThrowsOnPut(exception);
+        TestSubscriber<Object> ts = TestSubscriber.create();
+        Observable
+            .range(1, 100)
+            .groupBy(EVICTING_MAP_KEY_SELECTOR, EVICTING_MAP_ELEMENT_SELECTOR, mapFactory)
+            .flatMap(UtilityFunctions.<Observable<Integer>>identity())
+            .subscribe(ts);
+        ts.assertError(exception);
+    }
+    
+    @Test(expected = OnErrorNotImplementedException.class)
+    public void testEvictingMapFactoryIfMapPutThrowsFatalErrorThenErrorThrownBySubscribe() {
+        final RuntimeException exception = new OnErrorNotImplementedException("boo", new RuntimeException());
+        Func1<Action1<Integer>, Map<Integer, Object>> mapFactory = createMapFactoryThatThrowsOnPut(exception);
+        TestSubscriber<Object> ts = TestSubscriber.create();
+        Observable
+            .range(1, 100)
+            .groupBy(EVICTING_MAP_KEY_SELECTOR, EVICTING_MAP_ELEMENT_SELECTOR, mapFactory)
+            .flatMap(UtilityFunctions.<Observable<Integer>>identity())
+            .subscribe(ts);
+    }
+
+    private static Func1<Action1<Integer>, Map<Integer, Object>> createMapFactoryThatThrowsOnPut(
+            final RuntimeException exception) {
+        return new Func1<Action1<Integer>, Map<Integer, Object>>() {
+            @SuppressWarnings("serial")
+            @Override
+            public Map<Integer, Object> call(final Action1<Integer> evicted) {
+                // is a bit risky to override the put method because 
+                // of possible side-effects (e.g. remove could call put and we did not know it)
+                // to fix just need to use composition but needs a verbose implementation of Map
+                // interface
+                return new ConcurrentHashMap<Integer,Object>() {
+                    
+                    @Override
+                    public Object put(Integer key, Object value) {
+                        throw exception;
+                    }};
+            }};
+    }
+    
+    @Test
+    public void mapFactoryEvictionWorksWithGuavaCache() {
+        final List<Integer> evictedKeys = new ArrayList<Integer>();
+        Func1<Action1<Integer>, Map<Integer, Object>> mapFactory =
+            new Func1<Action1<Integer>, Map<Integer, Object>>() {
+                @Override
+                public Map<Integer, Object> call(final Action1<Integer> action) {
+                    return CacheBuilder.newBuilder()
+                        .maximumSize(5)
+                        .removalListener(new RemovalListener<Integer, Object>() {
+                            @Override
+                            public void onRemoval(RemovalNotification<Integer, Object> notification) {
+                                action.call(notification.getKey());
+                                evictedKeys.add(notification.getKey());                            
+                            }
+                        })
+                        .build().asMap();
+                }
+            };
+        TestSubscriber<String> ts = TestSubscriber.create();
+        Observable
+            .range(1, 100)
+            .groupBy(EVICTING_MAP_KEY_SELECTOR, EVICTING_MAP_ELEMENT_SELECTOR, mapFactory)
+            .flatMap(new Func1<GroupedObservable<Integer, Integer>, Observable<String>>() {
+                @Override
+                public Observable<String> call(final GroupedObservable<Integer, Integer> g) {
+                    return g.map(new Func1<Integer, String>() {
+                        @Override
+                        public String call(Integer x) {
+                            return g.getKey() + ":" + x;
+                        }
+                    });
+                }
+            })
+            .subscribe(ts);
+        assertEquals(
+            new HashSet<Integer>(Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)),
+            new HashSet<Integer>(evictedKeys));
+        List<String> expected = Observable
+                .range(1, 100)
+                .map(new Func1<Integer, String>() {
+                        @Override
+                        public String call(Integer x) {
+                            return (x /10) + ":" + x;
+                        }
+                    })
+                .toList().toBlocking().single();
+        assertEquals(expected, ts.getOnNextEvents());
+    }
+    
+    @Test(expected = NullPointerException.class)
+    public void testGroupByThrowsNpeIfEvictingMapFactoryNull() {
+        Observable
+        .range(1, 100)
+        .groupBy(EVICTING_MAP_KEY_SELECTOR, EVICTING_MAP_ELEMENT_SELECTOR, null);
+    }
+    
+    @Test
+    public void testEvictingMapFactoryIfMapCreateThrowsRuntimeExceptionThenErrorEmittedByStream() {
+        final RuntimeException exception = new RuntimeException("boo");
+        Func1<Action1<Integer>, Map<Integer, Object>> mapFactory = createMapFactoryThatThrowsOnCreate(exception);
+        TestSubscriber<Object> ts = TestSubscriber.create();
+        Observable
+            .range(1, 100)
+            .groupBy(EVICTING_MAP_KEY_SELECTOR, EVICTING_MAP_ELEMENT_SELECTOR, mapFactory)
+            .flatMap(UtilityFunctions.<Observable<Integer>>identity())
+            .subscribe(ts);
+        ts.assertError(exception);
+    }
+    
+    @Test(expected=OnErrorNotImplementedException.class)
+    public void testEvictingMapFactoryIfMapCreateThrowsFatalErrorThenSubscribeThrows() {
+        final OnErrorNotImplementedException exception = new OnErrorNotImplementedException("boo", new RuntimeException());
+        Func1<Action1<Integer>, Map<Integer, Object>> mapFactory = createMapFactoryThatThrowsOnCreate(exception);
+        TestSubscriber<Object> ts = TestSubscriber.create();
+        Observable
+            .range(1, 100)
+            .groupBy(EVICTING_MAP_KEY_SELECTOR, EVICTING_MAP_ELEMENT_SELECTOR, mapFactory)
+            .flatMap(UtilityFunctions.<Observable<Integer>>identity())
+            .subscribe(ts);
+    }
+
+    private static Func1<Action1<Integer>, Map<Integer, Object>> createMapFactoryThatThrowsOnCreate(
+            final RuntimeException exception) {
+        return new Func1<Action1<Integer>, Map<Integer, Object>>() {
+
+            @Override
+            public Map<Integer, Object> call(Action1<Integer> t) {
+                throw exception;
+            }};
+    }
 }

From a6d6ba98c84dc70fe3c117f69ad554e11ad3c2d4 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Sat, 25 Jun 2016 12:19:04 +0200
Subject: [PATCH 084/263] 1.x: Add Findbugs (#4099)

---
 build.gradle | 31 +++++++++++++++++++++++--------
 1 file changed, 23 insertions(+), 8 deletions(-)

diff --git a/build.gradle b/build.gradle
index 98d087ba40..7620a876d6 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,10 +1,10 @@
 buildscript {
-    repositories { 
-        jcenter() 
+    repositories {
+        jcenter()
     }
-    dependencies { 
+    dependencies {
         classpath 'com.netflix.nebula:gradle-rxjava-project-plugin:4.0.0'
-        classpath 'ru.vyarus:gradle-animalsniffer-plugin:1.1.0' 
+        classpath 'ru.vyarus:gradle-animalsniffer-plugin:1.1.0'
     }
 }
 
@@ -12,6 +12,7 @@ description = 'RxJava: Reactive Extensions for the JVM – a library for composi
 
 apply plugin: 'java'
 apply plugin: 'pmd'
+apply plugin: 'findbugs'
 apply plugin: 'jacoco'
 apply plugin: 'ru.vyarus.animalsniffer'
 apply plugin: 'nebula.rxjava-project'
@@ -98,15 +99,15 @@ pmdMain {
 task pmdPrint(dependsOn: 'pmdMain') << {
     File file = new File('build/reports/pmd/main.xml')
     if (file.exists()) {
-    
+
         println("Listing first 100 PMD violations")
-        
+
         file.eachLine { line, count ->
             if (count <= 100) {
                println(line)
             }
         }
-    
+
     } else {
         println("PMD file not found.")
     }
@@ -116,4 +117,18 @@ build.dependsOn pmdPrint
 
 animalsniffer {
     annotation = 'rx.internal.util.SuppressAnimalSniffer'
-}
\ No newline at end of file
+}
+
+findbugs {
+    ignoreFailures true
+    toolVersion = '3.0.1'
+    effort = 'max'
+    reportLevel = 'low'
+}
+
+findbugsMain {
+    reports {
+        html.enabled = false // Findbugs can only have on report enabled
+        xml.enabled = true
+    }
+}

From 4210577aed9d7b2efb9c51305f02d2c846b558c3 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 25 Jun 2016 14:02:31 +0200
Subject: [PATCH 085/263] 1.x: increase coverage of producers (#4117)

---
 .../producers/ProducerObserverArbiter.java    |   1 +
 .../producers/ProducerArbiterTest.java        | 125 ++++++++++++++
 .../ProducerObserverArbiterTest.java          | 163 ++++++++++++++++++
 .../producers/SingleDelayedProducerTest.java  |  64 +++++++
 .../producers/SingleProducerTest.java         |  63 +++++++
 5 files changed, 416 insertions(+)
 create mode 100644 src/test/java/rx/internal/producers/ProducerArbiterTest.java
 create mode 100644 src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java
 create mode 100644 src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
 create mode 100644 src/test/java/rx/internal/producers/SingleProducerTest.java

diff --git a/src/main/java/rx/internal/producers/ProducerObserverArbiter.java b/src/main/java/rx/internal/producers/ProducerObserverArbiter.java
index 46e86ba123..89a876acf9 100644
--- a/src/main/java/rx/internal/producers/ProducerObserverArbiter.java
+++ b/src/main/java/rx/internal/producers/ProducerObserverArbiter.java
@@ -69,6 +69,7 @@ public void onNext(T t) {
                 q.add(t);
                 return;
             }
+            emitting = true;
         }
         boolean skipFinal = false;
         try {
diff --git a/src/test/java/rx/internal/producers/ProducerArbiterTest.java b/src/test/java/rx/internal/producers/ProducerArbiterTest.java
new file mode 100644
index 0000000000..61b49ae380
--- /dev/null
+++ b/src/test/java/rx/internal/producers/ProducerArbiterTest.java
@@ -0,0 +1,125 @@
+/**
+ * Copyright 2015 Netflix, Inc.
+ *
+ * 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 rx.internal.producers;
+
+import org.junit.*;
+
+import rx.Producer;
+import rx.exceptions.TestException;
+
+public class ProducerArbiterTest {
+
+    @Test
+    public void negativeRequestThrows() {
+        ProducerArbiter pa = new ProducerArbiter();
+        try {
+            pa.request(-99);
+            Assert.fail("Failed to throw on invalid request amount");
+        } catch (IllegalArgumentException ex) {
+            Assert.assertEquals("n >= 0 required", ex.getMessage());
+        }
+    }
+
+    @Test
+    public void negativeProducedThrows() {
+        ProducerArbiter pa = new ProducerArbiter();
+        try {
+            pa.produced(-99);
+            Assert.fail("Failed to throw on invalid produced amount");
+        } catch (IllegalArgumentException ex) {
+            Assert.assertEquals("n > 0 required", ex.getMessage());
+        }
+    }
+
+    @Test
+    public void overproductionThrows() {
+        ProducerArbiter pa = new ProducerArbiter();
+        try {
+            pa.produced(1);
+            Assert.fail("Failed to throw on overproduction amount");
+        } catch (IllegalStateException ex) {
+            Assert.assertEquals("more items arrived than were requested", ex.getMessage());
+        }
+    }
+
+    @Test
+    public void nullProducerAccepted() {
+        ProducerArbiter pa = new ProducerArbiter();
+        pa.setProducer(null);
+    }
+
+    @Test
+    public void failedRequestUnlocksEmitting() {
+        ProducerArbiter pa = new ProducerArbiter();
+        pa.setProducer(new Producer() {
+            @Override
+            public void request(long n) {
+                if (n != 0) {
+                    throw new TestException("Forced failure");
+                }
+            }
+        });
+        try {
+            pa.request(1);
+            Assert.fail("Failed to throw on overproduction amount");
+        } catch (TestException ex) {
+            Assert.assertEquals("Forced failure", ex.getMessage());
+            Assert.assertFalse("Still emitting?!", pa.emitting);
+        }
+    }
+
+    @Test
+    public void reentrantSetProducerNull() {
+        final ProducerArbiter pa = new ProducerArbiter();
+        pa.setProducer(new Producer() {
+            @Override
+            public void request(long n) {
+                pa.setProducer(null);
+            }
+        });
+    }
+
+    @Test
+    public void reentrantSetProducer() {
+        final ProducerArbiter pa = new ProducerArbiter();
+        pa.setProducer(new Producer() {
+            @Override
+            public void request(long n) {
+                pa.setProducer(new ProducerArbiter());
+            }
+        });
+    }
+
+    @Test
+    public void overproductionReentrantThrows() {
+        final ProducerArbiter pa = new ProducerArbiter();
+        try {
+            pa.setProducer(new Producer() {
+                @Override
+                public void request(long n) {
+                    if (n != 0) {
+                        pa.produced(2);
+                    }
+                }
+            });
+            pa.request(1);
+            Assert.fail("Failed to throw on overproduction amount");
+        } catch (IllegalStateException ex) {
+            Assert.assertEquals("more produced than requested", ex.getMessage());
+        }
+    }
+
+}
diff --git a/src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java b/src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java
new file mode 100644
index 0000000000..8e0c826ba6
--- /dev/null
+++ b/src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java
@@ -0,0 +1,163 @@
+/**
+ * Copyright 2015 Netflix, Inc.
+ *
+ * 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 rx.internal.producers;
+
+import org.junit.*;
+
+import rx.*;
+import rx.exceptions.TestException;
+import rx.observers.*;
+
+public class ProducerObserverArbiterTest {
+
+    @Test
+    public void negativeRequestThrows() {
+        ProducerObserverArbiter<Integer> pa = new ProducerObserverArbiter<Integer>(Subscribers.empty());
+        try {
+            pa.request(-99);
+            Assert.fail("Failed to throw on invalid request amount");
+        } catch (IllegalArgumentException ex) {
+            Assert.assertEquals("n >= 0 required", ex.getMessage());
+        }
+    }
+
+    @Test
+    public void nullProducerAccepted() {
+        ProducerObserverArbiter<Integer> pa = new ProducerObserverArbiter<Integer>(Subscribers.empty());
+        pa.setProducer(null);
+    }
+
+    public void failedRequestUnlocksEmitting() {
+        ProducerObserverArbiter<Integer> pa = new ProducerObserverArbiter<Integer>(Subscribers.empty());
+        pa.setProducer(new Producer() {
+            @Override
+            public void request(long n) {
+                throw new TestException("Forced failure");
+            }
+        });
+        try {
+            pa.request(1);
+            Assert.fail("Failed to throw on overproduction amount");
+        } catch (TestException ex) {
+            Assert.assertEquals("Forced failure", ex.getMessage());
+            Assert.assertFalse("Still emitting?!", pa.emitting);
+        }
+    }
+
+    @Test
+    public void reentrantSetProducerNull() {
+        final ProducerObserverArbiter<Integer> pa = new ProducerObserverArbiter<Integer>(Subscribers.empty());
+        pa.setProducer(new Producer() {
+            @Override
+            public void request(long n) {
+                pa.setProducer(null);
+            }
+        });
+    }
+
+    @Test
+    public void reentrantSetProducer() {
+        final ProducerObserverArbiter<Integer> pa = new ProducerObserverArbiter<Integer>(Subscribers.empty());
+        pa.setProducer(new Producer() {
+            @Override
+            public void request(long n) {
+                pa.setProducer(new ProducerArbiter());
+            }
+        });
+    }
+
+    @Test
+    public void reentrantOnNext() {
+        @SuppressWarnings("rawtypes")
+        final Observer[] o = { null };
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
+            @SuppressWarnings("unchecked")
+            @Override
+            public void onNext(Integer t) {
+                if (t == 1) {
+                    o[0].onNext(2);
+                }
+                super.onNext(t);
+            }
+        };
+        ProducerObserverArbiter<Integer> poa = new ProducerObserverArbiter<Integer>(ts);
+        o[0] = poa;
+        poa.request(2);
+        poa.onNext(1);
+        ts.assertValues(1, 2);
+    }
+
+    @Test
+    public void reentrantOnError() {
+        @SuppressWarnings("rawtypes")
+        final Observer[] o = { null };
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                if (t == 1) {
+                    o[0].onError(new TestException());
+                }
+                super.onNext(t);
+            }
+        };
+        ProducerObserverArbiter<Integer> poa = new ProducerObserverArbiter<Integer>(ts);
+        o[0] = poa;
+        poa.onNext(1);
+        ts.assertValue(1);
+        ts.assertError(TestException.class);
+    }
+
+    @Test
+    public void reentrantOnCompleted() {
+        @SuppressWarnings("rawtypes")
+        final Observer[] o = { null };
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                if (t == 1) {
+                    o[0].onCompleted();
+                }
+                super.onNext(t);
+            }
+        };
+        ProducerObserverArbiter<Integer> poa = new ProducerObserverArbiter<Integer>(ts);
+        o[0] = poa;
+        poa.onNext(1);
+        ts.assertValue(1);
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void onNextThrows() {
+        @SuppressWarnings("rawtypes")
+        final Observer[] o = { null };
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                throw new TestException();
+            }
+        };
+        ProducerObserverArbiter<Integer> poa = new ProducerObserverArbiter<Integer>(ts);
+        o[0] = poa;
+        try {
+            poa.onNext(1);
+            Assert.fail("Arbiter didn't throw");
+        } catch (TestException ex) {
+            // expected
+        }
+    }
+
+}
diff --git a/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java b/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
new file mode 100644
index 0000000000..d40387b360
--- /dev/null
+++ b/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
@@ -0,0 +1,64 @@
+package rx.internal.producers;
+
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.*;
+
+import rx.Scheduler;
+import rx.functions.Action0;
+import rx.observers.*;
+import rx.schedulers.Schedulers;
+
+public class SingleDelayedProducerTest {
+
+    @Test
+    public void negativeRequestThrows() {
+        SingleDelayedProducer<Integer> pa = new SingleDelayedProducer<Integer>(Subscribers.empty());
+        try {
+            pa.request(-99);
+            Assert.fail("Failed to throw on invalid request amount");
+        } catch (IllegalArgumentException ex) {
+            Assert.assertEquals("n >= 0 required", ex.getMessage());
+        }
+    }
+
+    @Test
+    public void requestCompleteRace() throws Exception {
+        Scheduler.Worker w = Schedulers.computation().createWorker();
+        try {
+            for (int i = 0; i < 10000; i++) {
+                final AtomicInteger waiter = new AtomicInteger(2);
+
+                TestSubscriber<Integer> ts = TestSubscriber.create();
+                
+                final SingleDelayedProducer<Integer> pa = new SingleDelayedProducer<Integer>(ts);
+
+                final CountDownLatch cdl = new CountDownLatch(1);
+                
+                w.schedule(new Action0() {
+                    @Override
+                    public void call() {
+                        waiter.decrementAndGet();
+                        while (waiter.get() != 0) ;
+                        pa.request(1);
+                        cdl.countDown();
+                    }
+                });
+                
+                waiter.decrementAndGet();
+                while (waiter.get() != 0) ;
+                pa.setValue(1);
+                if (!cdl.await(5, TimeUnit.SECONDS)) {
+                    Assert.fail("The wait for completion timed out");
+                }
+                
+                ts.assertValue(1);
+                ts.assertCompleted();
+            }
+        } finally {
+            w.unsubscribe();
+        }
+    }
+
+}
diff --git a/src/test/java/rx/internal/producers/SingleProducerTest.java b/src/test/java/rx/internal/producers/SingleProducerTest.java
new file mode 100644
index 0000000000..faac28ba4d
--- /dev/null
+++ b/src/test/java/rx/internal/producers/SingleProducerTest.java
@@ -0,0 +1,63 @@
+package rx.internal.producers;
+
+import org.junit.*;
+
+import rx.Observable;
+import rx.exceptions.TestException;
+import rx.observers.*;
+
+public class SingleProducerTest {
+
+    @Test
+    public void negativeRequestThrows() {
+        SingleProducer<Integer> pa = new SingleProducer<Integer>(Subscribers.empty(), 1);
+        try {
+            pa.request(-99);
+            Assert.fail("Failed to throw on invalid request amount");
+        } catch (IllegalArgumentException ex) {
+            Assert.assertEquals("n >= 0 required", ex.getMessage());
+        }
+    }
+
+    @Test
+    public void cancelBeforeOnNext() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        SingleProducer<Integer> pa = new SingleProducer<Integer>(ts, 1);
+        
+        ts.unsubscribe();
+        
+        pa.request(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void cancelAfterOnNext() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        Observable.just(1).take(1).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void onNextThrows() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0) {
+            @Override
+            public void onNext(Integer t) {
+                throw new TestException();
+            }
+        };
+        SingleProducer<Integer> sp = new SingleProducer<Integer>(ts, 1);
+        
+        sp.request(1);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+}

From 1d75f4ae08ac8cf468ae86adcf02a566a727f59d Mon Sep 17 00:00:00 2001
From: Dmitriy Zaitsev <zaitsev.dl@gmail.com>
Date: Sat, 25 Jun 2016 16:13:35 +0300
Subject: [PATCH 086/263] 1.x: provide an explanation why certain tests are
 ignored (#4118)

---
 src/test/java/rx/BackpressureTests.java                      | 2 +-
 src/test/java/rx/IntervalDemo.java                           | 3 +--
 src/test/java/rx/internal/operators/OperatorFlatMapTest.java | 2 +-
 src/test/java/rx/observers/SerializedObserverTest.java       | 2 +-
 4 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/test/java/rx/BackpressureTests.java b/src/test/java/rx/BackpressureTests.java
index 393c8155cf..96e0ba8acc 100644
--- a/src/test/java/rx/BackpressureTests.java
+++ b/src/test/java/rx/BackpressureTests.java
@@ -192,7 +192,7 @@ public Observable<Integer> call(Integer i) {
     }
 
     @Test
-    @Ignore // the test is non-deterministic and can't be made deterministic
+    @Ignore("The test is non-deterministic and can't be made deterministic")
     public void testFlatMapAsync() {
         int NUM = (int) (RxRingBuffer.SIZE * 2.1);
         AtomicInteger c = new AtomicInteger();
diff --git a/src/test/java/rx/IntervalDemo.java b/src/test/java/rx/IntervalDemo.java
index 31c4cd679b..e95105e9d5 100644
--- a/src/test/java/rx/IntervalDemo.java
+++ b/src/test/java/rx/IntervalDemo.java
@@ -25,8 +25,7 @@
 import rx.functions.Action0;
 import rx.functions.Action1;
 
-@Ignore
-// since this doesn't do any automatic testing
+@Ignore("Since this doesn't do any automatic testing")
 public class IntervalDemo {
 
     @Test
diff --git a/src/test/java/rx/internal/operators/OperatorFlatMapTest.java b/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
index ce9712851a..2fa04b5c89 100644
--- a/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
+++ b/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
@@ -430,7 +430,7 @@ public void testFlatMapTransformsMaxConcurrentNormal() {
         verify(o, never()).onError(any(Throwable.class));
     }
     
-    @Ignore // don't care for any reordering
+    @Ignore("Don't care for any reordering")
     @Test(timeout = 10000)
     public void flatMapRangeAsyncLoop() {
         for (int i = 0; i < 2000; i++) {
diff --git a/src/test/java/rx/observers/SerializedObserverTest.java b/src/test/java/rx/observers/SerializedObserverTest.java
index 775017b1dd..9897843e3a 100644
--- a/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/src/test/java/rx/observers/SerializedObserverTest.java
@@ -336,7 +336,7 @@ public void onCompleted() {
      * 
      * @throws InterruptedException
      */
-    @Ignore
+    @Ignore("Demonstrates thread starvation problem. Read JavaDoc")
     @Test
     public void testThreadStarvation() throws InterruptedException {
 

From ed92ba833f05b7eb04ff7d592040656f9bcbcf32 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 25 Jun 2016 15:55:09 +0200
Subject: [PATCH 087/263] 1.x: increase coverage of internal utils, remove
 unused/unnecessary items (#4119)

* 1.x: increase coverage of internal utils, remove unused/unnecessary
items

* fix wrong assertion
---
 src/main/java/rx/Observable.java              |   2 +-
 .../operators/BlockingOperatorLatest.java     |   6 +-
 .../operators/BlockingOperatorMostRecent.java |   3 +-
 .../operators/BlockingOperatorNext.java       |   9 +-
 .../operators/BlockingOperatorToFuture.java   |  11 +-
 .../operators/BlockingOperatorToIterator.java |   9 +-
 .../operators/BufferUntilSubscriber.java      |   3 +-
 .../rx/internal/operators/OnSubscribeAmb.java |   7 +-
 .../operators/OnSubscribeAutoConnect.java     |   3 +-
 .../internal/operators/OnSubscribeDefer.java  |   3 +-
 .../OnSubscribeDelaySubscriptionOther.java    |   2 +-
 .../internal/operators/OnSubscribeDetach.java |   4 +-
 .../internal/operators/OnSubscribeFilter.java |   4 +-
 .../operators/OnSubscribeFlattenIterable.java |   3 +-
 .../operators/OnSubscribeFromCallable.java    |   7 +-
 .../internal/operators/OnSubscribeLift.java   |   2 +-
 .../rx/internal/operators/OnSubscribeMap.java |   4 +-
 .../operators/OnSubscribeOnAssembly.java      |   2 +-
 .../internal/operators/OnSubscribeRedo.java   |  18 +--
 .../operators/OnSubscribeRefCount.java        |  12 +-
 .../internal/operators/OnSubscribeSingle.java |   7 +-
 .../operators/OnSubscribeTimerOnce.java       |   4 +-
 .../OnSubscribeTimerPeriodically.java         |   4 +-
 .../OnSubscribeToObservableFuture.java        |   5 +-
 .../OperatorBufferWithSingleObservable.java   |   8 +-
 .../OperatorBufferWithStartEndObservable.java |   8 +-
 .../operators/OperatorBufferWithTime.java     |   9 +-
 .../rx/internal/operators/OperatorCast.java   |   4 +-
 .../OperatorDebounceWithSelector.java         |   3 +-
 .../operators/OperatorDebounceWithTime.java   |   4 +-
 .../rx/internal/operators/OperatorDelay.java  |   3 +-
 .../operators/OperatorDelayWithSelector.java  |   6 +-
 .../operators/OperatorDematerialize.java      |   3 +-
 .../internal/operators/OperatorDistinct.java  |   3 +-
 .../operators/OperatorDoOnRequest.java        |   3 +-
 .../operators/OperatorDoOnUnsubscribe.java    |   2 +-
 .../internal/operators/OperatorElementAt.java |   3 +-
 .../internal/operators/OperatorGroupBy.java   |   2 +-
 .../internal/operators/OperatorMapPair.java   |   4 +-
 .../internal/operators/OperatorMulticast.java |  10 +-
 .../OperatorOnBackpressureBuffer.java         |  14 +-
 .../operators/OperatorOnBackpressureDrop.java |   3 +-
 .../OperatorOnBackpressureLatest.java         |   2 +-
 .../operators/OperatorRetryWithPredicate.java |   8 +-
 .../operators/OperatorSampleWithTime.java     |   3 +-
 .../rx/internal/operators/OperatorScan.java   |   2 +-
 .../operators/OperatorSequenceEqual.java      |   8 +-
 .../rx/internal/operators/OperatorSingle.java |   4 +-
 .../internal/operators/OperatorSkipLast.java  |   3 +-
 .../operators/OperatorSkipLastTimed.java      |   6 +-
 .../internal/operators/OperatorSkipTimed.java |   4 +-
 .../internal/operators/OperatorSkipUntil.java |   4 +-
 .../internal/operators/OperatorSkipWhile.java |   3 +-
 .../rx/internal/operators/OperatorTake.java   |   3 +-
 .../operators/OperatorTakeLastOne.java        |   3 +-
 .../internal/operators/OperatorTakeTimed.java |   4 +-
 .../internal/operators/OperatorTakeUntil.java |   3 +-
 .../operators/OperatorTimeInterval.java       |   3 +-
 .../internal/operators/OperatorTimeout.java   |   4 +-
 .../OperatorTimeoutWithSelector.java          |   8 +-
 .../internal/operators/OperatorTimestamp.java |   3 +-
 .../rx/internal/operators/OperatorToMap.java  |   6 +-
 .../operators/OperatorToMultimap.java         |  10 +-
 .../operators/OperatorToObservableList.java   |   2 +-
 .../OperatorToObservableSortedList.java       |   2 +-
 .../operators/OperatorUnsubscribeOn.java      |   3 +-
 .../OperatorWindowWithObservable.java         |   4 +-
 .../OperatorWindowWithObservableFactory.java  |   4 +-
 .../OperatorWindowWithStartEndObservable.java |   4 +-
 .../operators/OperatorWindowWithTime.java     |   4 +-
 .../operators/OperatorWithLatestFromMany.java |   4 +-
 .../rx/internal/operators/OperatorZip.java    |  19 +--
 .../operators/OperatorZipIterable.java        |   2 +-
 .../operators/SingleDoAfterTerminate.java     |   4 +-
 .../operators/SingleOnSubscribeMap.java       |   4 +-
 .../SingleOperatorOnErrorResumeNext.java      |   3 +-
 .../java/rx/internal/util/ObjectPool.java     |   3 +-
 .../rx/internal/util/RxJavaPluginUtils.java   |  45 ------
 .../rx/internal/util/SynchronizedQueue.java   |   6 +-
 .../rx/internal/util/UtilityFunctions.java    | 104 --------------
 .../observers/AsyncCompletableSubscriber.java |   4 +-
 src/main/java/rx/observers/Observers.java     |   3 +-
 .../observers/SafeCompletableSubscriber.java  |   4 +-
 .../java/rx/observers/SafeSubscriber.java     |  23 ++--
 .../rx/observers/SerializedSubscriber.java    |   3 +-
 src/main/java/rx/plugins/RxJavaHooks.java     |  12 +-
 src/main/java/rx/subjects/ReplaySubject.java  |   4 +-
 .../internal/operators/OperatorCountTest.java |  36 +++++
 .../rx/internal/util/ExceptionUtilsTest.java  |  54 ++++++++
 .../internal/util/PlatformDependentTest.java  |  43 ++++++
 .../internal/util/SubscriptionListTest.java   |  53 +++++++-
 .../internal/util/SynchronizedQueueTest.java  | 128 +++++++++++++++++-
 .../internal/util/UtilityFunctionsTest.java   |  43 ++++++
 93 files changed, 523 insertions(+), 424 deletions(-)
 delete mode 100644 src/main/java/rx/internal/util/RxJavaPluginUtils.java
 create mode 100644 src/test/java/rx/internal/operators/OperatorCountTest.java
 create mode 100644 src/test/java/rx/internal/util/ExceptionUtilsTest.java
 create mode 100644 src/test/java/rx/internal/util/PlatformDependentTest.java
 create mode 100644 src/test/java/rx/internal/util/UtilityFunctionsTest.java

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index e3111e31ec..a63a2594ed 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -9158,7 +9158,7 @@ static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T
             Exceptions.throwIfFatal(e);
             // in case the subscriber can't listen to exceptions anymore
             if (subscriber.isUnsubscribed()) {
-                RxJavaPluginUtils.handleException(RxJavaHooks.onObservableError(e));
+                RxJavaHooks.onError(RxJavaHooks.onObservableError(e));
             } else {
                 // if an unhandled error occurs executing the onSubscribe we will propagate it
                 try {
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
index a07588007b..ca8aa231ce 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
@@ -15,14 +15,12 @@
  */
 package rx.internal.operators;
 
-import java.util.Iterator;
-import java.util.NoSuchElementException;
+import java.util.*;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicReference;
 
-import rx.Notification;
+import rx.*;
 import rx.Observable;
-import rx.Subscriber;
 import rx.exceptions.Exceptions;
 
 /**
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java b/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
index 507f1ee708..9157bb4877 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
@@ -15,8 +15,7 @@
  */
 package rx.internal.operators;
 
-import java.util.Iterator;
-import java.util.NoSuchElementException;
+import java.util.*;
 
 import rx.Observable;
 import rx.Subscriber;
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorNext.java b/src/main/java/rx/internal/operators/BlockingOperatorNext.java
index 236744ac31..a7aa16db16 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorNext.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorNext.java
@@ -15,15 +15,12 @@
  */
 package rx.internal.operators;
 
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.BlockingQueue;
+import java.util.*;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import rx.Notification;
+import rx.*;
 import rx.Observable;
-import rx.Subscriber;
 import rx.exceptions.Exceptions;
 
 /**
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java b/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
index ee43643fce..e4c6acd44f 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
@@ -15,17 +15,10 @@
  */
 package rx.internal.operators;
 
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicReference;
 
-import rx.Observable;
-import rx.Subscriber;
-import rx.Subscription;
+import rx.*;
 
 /**
  * Returns a Future representing the single value emitted by an Observable.
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java b/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java
index 60de1157c9..a8d405a3e5 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java
@@ -15,14 +15,11 @@
  */
 package rx.internal.operators;
 
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
+import java.util.*;
+import java.util.concurrent.*;
 
-import rx.Notification;
+import rx.*;
 import rx.Observable;
-import rx.Subscriber;
 import rx.exceptions.Exceptions;
 import rx.internal.util.RxRingBuffer;
 
diff --git a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
index f97198ee28..e517cbc9db 100644
--- a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
+++ b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
@@ -18,8 +18,7 @@
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicReference;
 
-import rx.Observer;
-import rx.Subscriber;
+import rx.*;
 import rx.functions.Action0;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeAmb.java b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
index f10e73396c..7469e7c417 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeAmb.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
@@ -15,16 +15,13 @@
  */
 package rx.internal.operators;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicReference;
 
+import rx.*;
 import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.Producer;
-import rx.Subscriber;
 import rx.functions.Action0;
 import rx.subscriptions.Subscriptions;
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java b/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
index 75ea9c82cf..135888d310 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
@@ -17,9 +17,8 @@
 
 import java.util.concurrent.atomic.AtomicInteger;
 
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Subscriber;
-import rx.Subscription;
 import rx.functions.Action1;
 import rx.observables.ConnectableObservable;
 import rx.observers.Subscribers;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDefer.java b/src/main/java/rx/internal/operators/OnSubscribeDefer.java
index c3dff6914b..35b278b682 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDefer.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDefer.java
@@ -15,9 +15,8 @@
  */
 package rx.internal.operators;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Subscriber;
 import rx.exceptions.Exceptions;
 import rx.functions.Func0;
 import rx.observers.Subscribers;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java
index d25d940d61..a9ae84b7ef 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java
@@ -19,7 +19,7 @@
 import rx.*;
 import rx.Observable.OnSubscribe;
 import rx.observers.Subscribers;
-import rx.plugins.*;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.*;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDetach.java b/src/main/java/rx/internal/operators/OnSubscribeDetach.java
index e736583c85..d883b6c49f 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDetach.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDetach.java
@@ -19,7 +19,7 @@
 
 import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Nulls out references to upstream data structures when the source terminates or 
@@ -80,7 +80,7 @@ public void onError(Throwable e) {
             if (a != null) {
                 a.onError(e);
             } else {
-                RxJavaPluginUtils.handleException(e);
+                RxJavaHooks.onError(e);
             }
         }
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFilter.java b/src/main/java/rx/internal/operators/OnSubscribeFilter.java
index 2fe3abcde0..cc0b4f63bc 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFilter.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFilter.java
@@ -19,7 +19,7 @@
 import rx.Observable.OnSubscribe;
 import rx.exceptions.*;
 import rx.functions.Func1;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Filters an Observable by discarding any items it emits that do not meet some test.
@@ -82,7 +82,7 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable e) {
             if (done) {
-                RxJavaPluginUtils.handleException(e);
+                RxJavaHooks.onError(e);
                 return;
             }
             done = true;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
index fb3b9f97bd..9a0c907060 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
@@ -27,6 +27,7 @@
 import rx.internal.util.*;
 import rx.internal.util.atomic.*;
 import rx.internal.util.unsafe.*;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Flattens a sequence if Iterable sources, generated via a function, into a single sequence.
@@ -136,7 +137,7 @@ public void onError(Throwable e) {
                 done = true;
                 drain();
             } else {
-                RxJavaPluginUtils.handleException(e);
+                RxJavaHooks.onError(e);
             }
         }
         
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java b/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java
index 2a81e9f1f0..98128e15ff 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromCallable.java
@@ -16,13 +16,12 @@
 
 package rx.internal.operators;
 
-import rx.Observable;
-import rx.Subscriber;
+import java.util.concurrent.Callable;
+
+import rx.*;
 import rx.exceptions.Exceptions;
 import rx.internal.producers.SingleDelayedProducer;
 
-import java.util.concurrent.Callable;
-
 /**
  * Do not invoke the function until an Observer subscribes; Invokes function on each
  * subscription.
diff --git a/src/main/java/rx/internal/operators/OnSubscribeLift.java b/src/main/java/rx/internal/operators/OnSubscribeLift.java
index 65f6f20d14..fd987d5800 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeLift.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeLift.java
@@ -19,7 +19,7 @@
 import rx.Observable.*;
 import rx.Subscriber;
 import rx.exceptions.Exceptions;
-import rx.plugins.*;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Transforms the downstream Subscriber into a Subscriber via an operator
diff --git a/src/main/java/rx/internal/operators/OnSubscribeMap.java b/src/main/java/rx/internal/operators/OnSubscribeMap.java
index 0ad3ea39e8..0dc74df445 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeMap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeMap.java
@@ -19,7 +19,7 @@
 import rx.Observable.OnSubscribe;
 import rx.exceptions.*;
 import rx.functions.Func1;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Applies a function of your choosing to every item emitted by an {@code Observable}, and emits the results of
@@ -80,7 +80,7 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable e) {
             if (done) {
-                RxJavaPluginUtils.handleException(e);
+                RxJavaHooks.onError(e);
                 return;
             }
             done = true;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
index fd338c1ece..11c7bcff0e 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
@@ -15,8 +15,8 @@
  */
 package rx.internal.operators;
 
-import rx.*;
 import rx.Observable.OnSubscribe;
+import rx.Subscriber;
 import rx.exceptions.AssemblyStackTraceException;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeRedo.java b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
index c41b211558..f9cba08127 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRedo.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
@@ -33,19 +33,11 @@
 
 import static rx.Observable.create;
 
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-
-import rx.Notification;
-import rx.Observable;
-import rx.Observable.OnSubscribe;
-import rx.Observable.Operator;
-import rx.Producer;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.functions.Action0;
-import rx.functions.Func1;
-import rx.functions.Func2;
+import java.util.concurrent.atomic.*;
+
+import rx.*;
+import rx.Observable.*;
+import rx.functions.*;
 import rx.internal.producers.ProducerArbiter;
 import rx.observers.Subscribers;
 import rx.schedulers.Schedulers;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeRefCount.java b/src/main/java/rx/internal/operators/OnSubscribeRefCount.java
index 82ec0e6c38..7bcc9872c8 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRefCount.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRefCount.java
@@ -15,18 +15,14 @@
  */
 package rx.internal.operators;
 
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.*;
 import java.util.concurrent.locks.ReentrantLock;
 
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.functions.Action1;
+import rx.functions.*;
 import rx.observables.ConnectableObservable;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.Subscriptions;
+import rx.subscriptions.*;
 
 /**
  * Returns an observable sequence that stays connected to the source as long as
diff --git a/src/main/java/rx/internal/operators/OnSubscribeSingle.java b/src/main/java/rx/internal/operators/OnSubscribeSingle.java
index 90dc8d288e..7c2d8f2970 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeSingle.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeSingle.java
@@ -15,13 +15,10 @@
  */
 package rx.internal.operators;
 
-import rx.Observable;
-import rx.Single;
-import rx.SingleSubscriber;
-import rx.Subscriber;
-
 import java.util.NoSuchElementException;
 
+import rx.*;
+
 /**
  * Allows conversion of an Observable to a Single ensuring that exactly one item is emitted - no more and no less.
  * Also forwards errors as appropriate.
diff --git a/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java b/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java
index 4d2a7389b2..8cd0c77618 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java
@@ -16,11 +16,11 @@
 package rx.internal.operators;
 
 import java.util.concurrent.TimeUnit;
+
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Scheduler;
 import rx.Scheduler.Worker;
 import rx.exceptions.Exceptions;
-import rx.Subscriber;
 import rx.functions.Action0;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java b/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java
index dedf978f96..0782f5130c 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java
@@ -16,11 +16,11 @@
 package rx.internal.operators;
 
 import java.util.concurrent.TimeUnit;
+
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Scheduler;
 import rx.Scheduler.Worker;
 import rx.exceptions.Exceptions;
-import rx.Subscriber;
 import rx.functions.Action0;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java b/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
index 573c4065cd..2c36da8611 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
@@ -15,12 +15,11 @@
  */
 package rx.internal.operators;
 
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
 
 import rx.Observable.OnSubscribe;
-import rx.exceptions.Exceptions;
 import rx.Subscriber;
+import rx.exceptions.Exceptions;
 import rx.functions.Action0;
 import rx.internal.producers.SingleProducer;
 import rx.subscriptions.Subscriptions;
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java b/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
index b5f9a68493..4c86c8b089 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
@@ -15,17 +15,15 @@
  */
 package rx.internal.operators;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 
 import rx.Observable;
 import rx.Observable.Operator;
-import rx.exceptions.Exceptions;
 import rx.Observer;
 import rx.Subscriber;
+import rx.exceptions.Exceptions;
 import rx.functions.Func0;
-import rx.observers.SerializedSubscriber;
-import rx.observers.Subscribers;
+import rx.observers.*;
 
 /**
  * This operation takes
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java b/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
index 9938bc4534..383a82b3d8 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
@@ -15,15 +15,13 @@
  */
 package rx.internal.operators;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
+import java.util.*;
+
 import rx.Observable;
 import rx.Observable.Operator;
-import rx.exceptions.Exceptions;
 import rx.Observer;
 import rx.Subscriber;
+import rx.exceptions.Exceptions;
 import rx.functions.Func1;
 import rx.observers.SerializedSubscriber;
 import rx.subscriptions.CompositeSubscription;
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithTime.java b/src/main/java/rx/internal/operators/OperatorBufferWithTime.java
index b13fe2fa9e..76fd0ba37b 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithTime.java
@@ -15,16 +15,13 @@
  */
 package rx.internal.operators;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
+
+import rx.*;
 import rx.Observable;
 import rx.Observable.Operator;
-import rx.Scheduler;
 import rx.Scheduler.Worker;
-import rx.Subscriber;
 import rx.exceptions.Exceptions;
 import rx.functions.Action0;
 import rx.observers.SerializedSubscriber;
diff --git a/src/main/java/rx/internal/operators/OperatorCast.java b/src/main/java/rx/internal/operators/OperatorCast.java
index be14ef91e8..e5b2f76176 100644
--- a/src/main/java/rx/internal/operators/OperatorCast.java
+++ b/src/main/java/rx/internal/operators/OperatorCast.java
@@ -18,7 +18,7 @@
 import rx.*;
 import rx.Observable.Operator;
 import rx.exceptions.*;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Converts the elements of an observable sequence to the specified type.
@@ -72,7 +72,7 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable e) {
             if (done) {
-                RxJavaPluginUtils.handleException(e);
+                RxJavaHooks.onError(e);
                 return;
             }
             done = true;
diff --git a/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java b/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java
index 6be5ff2210..e530d38a66 100644
--- a/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java
+++ b/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java
@@ -15,10 +15,9 @@
  */
 package rx.internal.operators;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.Operator;
 import rx.exceptions.Exceptions;
-import rx.Subscriber;
 import rx.functions.Func1;
 import rx.internal.operators.OperatorDebounceWithTime.DebounceState;
 import rx.observers.SerializedSubscriber;
diff --git a/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java b/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
index 50c2418228..874f9c9e54 100644
--- a/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
@@ -16,11 +16,11 @@
 package rx.internal.operators;
 
 import java.util.concurrent.TimeUnit;
+
+import rx.*;
 import rx.Observable.Operator;
-import rx.Scheduler;
 import rx.Scheduler.Worker;
 import rx.exceptions.Exceptions;
-import rx.Subscriber;
 import rx.functions.Action0;
 import rx.observers.SerializedSubscriber;
 import rx.subscriptions.SerialSubscription;
diff --git a/src/main/java/rx/internal/operators/OperatorDelay.java b/src/main/java/rx/internal/operators/OperatorDelay.java
index 7edf5199b3..35d23cf9c1 100644
--- a/src/main/java/rx/internal/operators/OperatorDelay.java
+++ b/src/main/java/rx/internal/operators/OperatorDelay.java
@@ -17,10 +17,9 @@
 
 import java.util.concurrent.TimeUnit;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Scheduler;
 import rx.Scheduler.Worker;
-import rx.Subscriber;
 import rx.functions.Action0;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorDelayWithSelector.java b/src/main/java/rx/internal/operators/OperatorDelayWithSelector.java
index 1c4447c1d2..7211b18586 100644
--- a/src/main/java/rx/internal/operators/OperatorDelayWithSelector.java
+++ b/src/main/java/rx/internal/operators/OperatorDelayWithSelector.java
@@ -15,13 +15,11 @@
  */
 package rx.internal.operators;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.Operator;
 import rx.exceptions.Exceptions;
-import rx.Subscriber;
 import rx.functions.Func1;
-import rx.observers.SerializedSubscriber;
-import rx.observers.Subscribers;
+import rx.observers.*;
 import rx.subjects.PublishSubject;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorDematerialize.java b/src/main/java/rx/internal/operators/OperatorDematerialize.java
index 23eea9f1e8..d7b27b094d 100644
--- a/src/main/java/rx/internal/operators/OperatorDematerialize.java
+++ b/src/main/java/rx/internal/operators/OperatorDematerialize.java
@@ -15,9 +15,8 @@
  */
 package rx.internal.operators;
 
-import rx.Notification;
+import rx.*;
 import rx.Observable.Operator;
-import rx.Subscriber;
 
 /**
  * Reverses the effect of {@link OperatorMaterialize} by transforming the Notification objects
diff --git a/src/main/java/rx/internal/operators/OperatorDistinct.java b/src/main/java/rx/internal/operators/OperatorDistinct.java
index 716353e272..551cd741f9 100644
--- a/src/main/java/rx/internal/operators/OperatorDistinct.java
+++ b/src/main/java/rx/internal/operators/OperatorDistinct.java
@@ -15,8 +15,7 @@
  */
 package rx.internal.operators;
 
-import java.util.HashSet;
-import java.util.Set;
+import java.util.*;
 
 import rx.Observable.Operator;
 import rx.Subscriber;
diff --git a/src/main/java/rx/internal/operators/OperatorDoOnRequest.java b/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
index e59d1f04d5..c350105d08 100644
--- a/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
+++ b/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
@@ -15,9 +15,8 @@
  */
 package rx.internal.operators;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Producer;
-import rx.Subscriber;
 import rx.functions.Action1;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorDoOnUnsubscribe.java b/src/main/java/rx/internal/operators/OperatorDoOnUnsubscribe.java
index 217c46977f..ab7b0ea4cb 100644
--- a/src/main/java/rx/internal/operators/OperatorDoOnUnsubscribe.java
+++ b/src/main/java/rx/internal/operators/OperatorDoOnUnsubscribe.java
@@ -16,7 +16,7 @@
 package rx.internal.operators;
 
 import rx.Observable.Operator;
-import rx.*;
+import rx.Subscriber;
 import rx.functions.Action0;
 import rx.observers.Subscribers;
 import rx.subscriptions.Subscriptions;
diff --git a/src/main/java/rx/internal/operators/OperatorElementAt.java b/src/main/java/rx/internal/operators/OperatorElementAt.java
index 3fa581b8d2..4a8531af37 100644
--- a/src/main/java/rx/internal/operators/OperatorElementAt.java
+++ b/src/main/java/rx/internal/operators/OperatorElementAt.java
@@ -17,9 +17,8 @@
 
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Producer;
-import rx.Subscriber;
 
 /**
  * Returns the element at a specified index in a sequence.
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index b6c2e08bd1..55e13fe8c7 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -26,8 +26,8 @@
 import rx.internal.producers.ProducerArbiter;
 import rx.internal.util.*;
 import rx.observables.GroupedObservable;
-import rx.plugins.RxJavaHooks;
 import rx.observers.Subscribers;
+import rx.plugins.RxJavaHooks;
 import rx.subscriptions.Subscriptions;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorMapPair.java b/src/main/java/rx/internal/operators/OperatorMapPair.java
index a9733c7d88..c4f65605d3 100644
--- a/src/main/java/rx/internal/operators/OperatorMapPair.java
+++ b/src/main/java/rx/internal/operators/OperatorMapPair.java
@@ -19,7 +19,7 @@
 import rx.Observable.Operator;
 import rx.exceptions.*;
 import rx.functions.*;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.plugins.RxJavaHooks;
 
 /**
  * An {@link Operator} that pairs up items emitted by a source {@link Observable} with the sequence of items
@@ -105,7 +105,7 @@ public void onNext(T outer) {
         @Override
         public void onError(Throwable e) {
             if (done) {
-                RxJavaPluginUtils.handleException(e);
+                RxJavaHooks.onError(e);
                 return;
             }
             done = true;
diff --git a/src/main/java/rx/internal/operators/OperatorMulticast.java b/src/main/java/rx/internal/operators/OperatorMulticast.java
index 965b850f5d..c728fdc465 100644
--- a/src/main/java/rx/internal/operators/OperatorMulticast.java
+++ b/src/main/java/rx/internal/operators/OperatorMulticast.java
@@ -15,16 +15,12 @@
  */
 package rx.internal.operators;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicReference;
 
+import rx.*;
 import rx.Observable;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.functions.Func0;
+import rx.functions.*;
 import rx.observables.ConnectableObservable;
 import rx.observers.Subscribers;
 import rx.subjects.Subject;
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
index 8c14a70334..3a9f8f2b4b 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
@@ -15,20 +15,18 @@
  */
 package rx.internal.operators;
 
+import static rx.BackpressureOverflow.ON_OVERFLOW_DEFAULT;
+
 import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.*;
 
+import rx.*;
+import rx.BackpressureOverflow.Strategy;
 import rx.Observable.Operator;
-import rx.Producer;
-import rx.Subscriber;
-import rx.exceptions.Exceptions;
-import rx.exceptions.MissingBackpressureException;
+import rx.exceptions.*;
 import rx.functions.Action0;
 import rx.internal.util.BackpressureDrainManager;
 
-import static rx.BackpressureOverflow.*;
-
 public class OperatorOnBackpressureBuffer<T> implements Operator<T, T> {
 
     private final Long capacity;
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
index 63e13da125..c976fba197 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
@@ -17,9 +17,8 @@
 
 import java.util.concurrent.atomic.AtomicLong;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Producer;
-import rx.Subscriber;
 import rx.exceptions.Exceptions;
 import rx.functions.Action1;
 
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java
index 02225d3afc..230ec153e1 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java
@@ -17,8 +17,8 @@
 
 import java.util.concurrent.atomic.*;
 
-import rx.Observable.Operator;
 import rx.*;
+import rx.Observable.Operator;
 
 /**
  * An operator which drops all but the last received value in case the downstream
diff --git a/src/main/java/rx/internal/operators/OperatorRetryWithPredicate.java b/src/main/java/rx/internal/operators/OperatorRetryWithPredicate.java
index 0e5111b6c4..20c0565db5 100644
--- a/src/main/java/rx/internal/operators/OperatorRetryWithPredicate.java
+++ b/src/main/java/rx/internal/operators/OperatorRetryWithPredicate.java
@@ -17,12 +17,8 @@
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-import rx.Observable;
-import rx.Producer;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.functions.Action0;
-import rx.functions.Func2;
+import rx.*;
+import rx.functions.*;
 import rx.internal.producers.ProducerArbiter;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.SerialSubscription;
diff --git a/src/main/java/rx/internal/operators/OperatorSampleWithTime.java b/src/main/java/rx/internal/operators/OperatorSampleWithTime.java
index e4c4a82c53..dc9de738a6 100644
--- a/src/main/java/rx/internal/operators/OperatorSampleWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorSampleWithTime.java
@@ -18,11 +18,10 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Scheduler;
 import rx.Scheduler.Worker;
 import rx.exceptions.Exceptions;
-import rx.Subscriber;
 import rx.functions.Action0;
 import rx.observers.SerializedSubscriber;
 
diff --git a/src/main/java/rx/internal/operators/OperatorScan.java b/src/main/java/rx/internal/operators/OperatorScan.java
index e386c6cb16..e621bce68a 100644
--- a/src/main/java/rx/internal/operators/OperatorScan.java
+++ b/src/main/java/rx/internal/operators/OperatorScan.java
@@ -20,7 +20,7 @@
 
 import rx.*;
 import rx.Observable.Operator;
-import rx.exceptions.*;
+import rx.exceptions.Exceptions;
 import rx.functions.*;
 import rx.internal.util.atomic.SpscLinkedAtomicQueue;
 import rx.internal.util.unsafe.*;
diff --git a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
index 05ad83bdc9..a3fa333035 100644
--- a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
+++ b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
@@ -15,12 +15,10 @@
  */
 package rx.internal.operators;
 
-import static rx.Observable.concat;
-import static rx.Observable.just;
-import static rx.Observable.zip;
+import static rx.Observable.*;
+
 import rx.Observable;
-import rx.functions.Func1;
-import rx.functions.Func2;
+import rx.functions.*;
 import rx.internal.util.UtilityFunctions;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorSingle.java b/src/main/java/rx/internal/operators/OperatorSingle.java
index 7984d06786..942f53ab15 100644
--- a/src/main/java/rx/internal/operators/OperatorSingle.java
+++ b/src/main/java/rx/internal/operators/OperatorSingle.java
@@ -20,7 +20,7 @@
 import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.internal.producers.SingleProducer;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.plugins.RxJavaHooks;
 
 /**
  * If the Observable completes after emitting a single item that matches a
@@ -124,7 +124,7 @@ public void onCompleted() {
         @Override
         public void onError(Throwable e) {
             if (hasTooManyElements) {
-                RxJavaPluginUtils.handleException(e);
+                RxJavaHooks.onError(e);
                 return;
             }
             
diff --git a/src/main/java/rx/internal/operators/OperatorSkipLast.java b/src/main/java/rx/internal/operators/OperatorSkipLast.java
index 87276382bb..1dd412e94a 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipLast.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipLast.java
@@ -15,8 +15,7 @@
  */
 package rx.internal.operators;
 
-import java.util.ArrayDeque;
-import java.util.Deque;
+import java.util.*;
 
 import rx.Observable.Operator;
 import rx.Subscriber;
diff --git a/src/main/java/rx/internal/operators/OperatorSkipLastTimed.java b/src/main/java/rx/internal/operators/OperatorSkipLastTimed.java
index b3fe766308..1662dffbc2 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipLastTimed.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipLastTimed.java
@@ -15,13 +15,11 @@
  */
 package rx.internal.operators;
 
-import java.util.ArrayDeque;
-import java.util.Deque;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Scheduler;
-import rx.Subscriber;
 import rx.schedulers.Timestamped;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorSkipTimed.java b/src/main/java/rx/internal/operators/OperatorSkipTimed.java
index 77e1fe1322..78a527ef94 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipTimed.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipTimed.java
@@ -17,10 +17,10 @@
 
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+
+import rx.*;
 import rx.Observable.Operator;
-import rx.Scheduler;
 import rx.Scheduler.Worker;
-import rx.Subscriber;
 import rx.functions.Action0;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorSkipUntil.java b/src/main/java/rx/internal/operators/OperatorSkipUntil.java
index e4270b2010..5abff347db 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipUntil.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipUntil.java
@@ -16,9 +16,9 @@
 package rx.internal.operators;
 
 import java.util.concurrent.atomic.AtomicBoolean;
-import rx.Observable;
+
+import rx.*;
 import rx.Observable.Operator;
-import rx.Subscriber;
 import rx.observers.SerializedSubscriber;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorSkipWhile.java b/src/main/java/rx/internal/operators/OperatorSkipWhile.java
index 328c2a7b4b..c291569ea6 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipWhile.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipWhile.java
@@ -18,8 +18,7 @@
 import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.exceptions.Exceptions;
-import rx.functions.Func1;
-import rx.functions.Func2;
+import rx.functions.*;
 
 /**
  * Skips any emitted source items as long as the specified condition holds true. Emits all further source items
diff --git a/src/main/java/rx/internal/operators/OperatorTake.java b/src/main/java/rx/internal/operators/OperatorTake.java
index c8b600acfc..51be87e178 100644
--- a/src/main/java/rx/internal/operators/OperatorTake.java
+++ b/src/main/java/rx/internal/operators/OperatorTake.java
@@ -17,9 +17,8 @@
 
 import java.util.concurrent.atomic.AtomicLong;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Producer;
-import rx.Subscriber;
 
 /**
  * An {@code Observable} that emits the first {@code num} items emitted by the source {@code Observable}.
diff --git a/src/main/java/rx/internal/operators/OperatorTakeLastOne.java b/src/main/java/rx/internal/operators/OperatorTakeLastOne.java
index a1ab397ba5..9625608d02 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeLastOne.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeLastOne.java
@@ -18,10 +18,9 @@
 
 import java.util.concurrent.atomic.AtomicInteger;
 
+import rx.*;
 import rx.Observable.Operator;
 import rx.exceptions.Exceptions;
-import rx.Producer;
-import rx.Subscriber;
 
 public class OperatorTakeLastOne<T> implements Operator<T, T> {
 
diff --git a/src/main/java/rx/internal/operators/OperatorTakeTimed.java b/src/main/java/rx/internal/operators/OperatorTakeTimed.java
index faa95b4b79..91bd05c5ab 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeTimed.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeTimed.java
@@ -16,10 +16,10 @@
 package rx.internal.operators;
 
 import java.util.concurrent.TimeUnit;
+
+import rx.*;
 import rx.Observable.Operator;
-import rx.Scheduler;
 import rx.Scheduler.Worker;
-import rx.Subscriber;
 import rx.functions.Action0;
 import rx.observers.SerializedSubscriber;
 
diff --git a/src/main/java/rx/internal/operators/OperatorTakeUntil.java b/src/main/java/rx/internal/operators/OperatorTakeUntil.java
index dad80632b4..56778a866c 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeUntil.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeUntil.java
@@ -15,9 +15,8 @@
  */
 package rx.internal.operators;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.Operator;
-import rx.Subscriber;
 import rx.observers.SerializedSubscriber;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorTimeInterval.java b/src/main/java/rx/internal/operators/OperatorTimeInterval.java
index 606f4d529f..17f370e721 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeInterval.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeInterval.java
@@ -15,9 +15,8 @@
  */
 package rx.internal.operators;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Scheduler;
-import rx.Subscriber;
 import rx.schedulers.TimeInterval;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorTimeout.java b/src/main/java/rx/internal/operators/OperatorTimeout.java
index 8234669508..e7d13d32ad 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeout.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeout.java
@@ -17,9 +17,7 @@
 
 import java.util.concurrent.TimeUnit;
 
-import rx.Observable;
-import rx.Scheduler;
-import rx.Subscription;
+import rx.*;
 import rx.functions.Action0;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java b/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
index 1e6c20e8a2..9497b1188f 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
@@ -15,13 +15,9 @@
  */
 package rx.internal.operators;
 
-import rx.Observable;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.Subscription;
+import rx.*;
 import rx.exceptions.Exceptions;
-import rx.functions.Func0;
-import rx.functions.Func1;
+import rx.functions.*;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 
diff --git a/src/main/java/rx/internal/operators/OperatorTimestamp.java b/src/main/java/rx/internal/operators/OperatorTimestamp.java
index 5d0706afa4..9068f5d088 100644
--- a/src/main/java/rx/internal/operators/OperatorTimestamp.java
+++ b/src/main/java/rx/internal/operators/OperatorTimestamp.java
@@ -15,9 +15,8 @@
  */
 package rx.internal.operators;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Scheduler;
-import rx.Subscriber;
 import rx.schedulers.Timestamped;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorToMap.java b/src/main/java/rx/internal/operators/OperatorToMap.java
index 725340982a..c346d7476b 100644
--- a/src/main/java/rx/internal/operators/OperatorToMap.java
+++ b/src/main/java/rx/internal/operators/OperatorToMap.java
@@ -16,14 +16,12 @@
 
 package rx.internal.operators;
 
-import java.util.HashMap;
-import java.util.Map;
+import java.util.*;
 
 import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.exceptions.Exceptions;
-import rx.functions.Func0;
-import rx.functions.Func1;
+import rx.functions.*;
 import rx.observers.Subscribers;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorToMultimap.java b/src/main/java/rx/internal/operators/OperatorToMultimap.java
index 10e1cbb373..affdc080f4 100644
--- a/src/main/java/rx/internal/operators/OperatorToMultimap.java
+++ b/src/main/java/rx/internal/operators/OperatorToMultimap.java
@@ -16,16 +16,12 @@
 
 package rx.internal.operators;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.*;
 
 import rx.Observable.Operator;
-import rx.exceptions.Exceptions;
 import rx.Subscriber;
-import rx.functions.Func0;
-import rx.functions.Func1;
+import rx.exceptions.Exceptions;
+import rx.functions.*;
 import rx.observers.Subscribers;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorToObservableList.java b/src/main/java/rx/internal/operators/OperatorToObservableList.java
index bde9947eaa..670a83ce7a 100644
--- a/src/main/java/rx/internal/operators/OperatorToObservableList.java
+++ b/src/main/java/rx/internal/operators/OperatorToObservableList.java
@@ -18,8 +18,8 @@
 import java.util.*;
 
 import rx.Observable.Operator;
+import rx.Subscriber;
 import rx.exceptions.Exceptions;
-import rx.*;
 import rx.internal.producers.SingleDelayedProducer;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java b/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java
index 72c1536a22..3de4f14e21 100644
--- a/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java
+++ b/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java
@@ -18,8 +18,8 @@
 import java.util.*;
 
 import rx.Observable.Operator;
+import rx.Subscriber;
 import rx.exceptions.Exceptions;
-import rx.*;
 import rx.functions.Func2;
 import rx.internal.producers.SingleDelayedProducer;
 
diff --git a/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java b/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
index f0b0151063..21c424457c 100644
--- a/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
+++ b/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
@@ -15,9 +15,8 @@
  */
 package rx.internal.operators;
 
+import rx.*;
 import rx.Observable.Operator;
-import rx.Scheduler;
-import rx.Subscriber;
 import rx.functions.Action0;
 import rx.subscriptions.Subscriptions;
 
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java b/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
index 616e644c8c..c5a56e9b6d 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
@@ -17,10 +17,10 @@
 
 import java.util.*;
 
-import rx.*;
-import rx.Observable.Operator;
 import rx.Observable;
+import rx.Observable.Operator;
 import rx.Observer;
+import rx.Subscriber;
 import rx.observers.SerializedSubscriber;
 import rx.subjects.UnicastSubject;
 
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
index 80f6a95080..6cbc4264d2 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
@@ -17,10 +17,10 @@
 
 import java.util.*;
 
-import rx.*;
-import rx.Observable.Operator;
 import rx.Observable;
+import rx.Observable.Operator;
 import rx.Observer;
+import rx.Subscriber;
 import rx.functions.Func0;
 import rx.observers.SerializedSubscriber;
 import rx.subjects.UnicastSubject;
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java b/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
index bc6b601f34..5b28564bc0 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
@@ -17,10 +17,10 @@
 
 import java.util.*;
 
-import rx.*;
-import rx.Observable.Operator;
 import rx.Observable;
+import rx.Observable.Operator;
 import rx.Observer;
+import rx.Subscriber;
 import rx.functions.Func1;
 import rx.observers.*;
 import rx.subjects.UnicastSubject;
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithTime.java b/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
index beacce2cdf..ad7b459dc2 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
@@ -19,10 +19,10 @@
 import java.util.concurrent.TimeUnit;
 
 import rx.*;
-import rx.Observable.Operator;
-import rx.Scheduler.Worker;
 import rx.Observable;
+import rx.Observable.Operator;
 import rx.Observer;
+import rx.Scheduler.Worker;
 import rx.functions.Action0;
 import rx.observers.*;
 import rx.subjects.UnicastSubject;
diff --git a/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java b/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java
index 8339eabf58..b4a39bc642 100644
--- a/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java
+++ b/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java
@@ -22,8 +22,8 @@
 import rx.Observable.OnSubscribe;
 import rx.exceptions.Exceptions;
 import rx.functions.FuncN;
-import rx.internal.util.RxJavaPluginUtils;
 import rx.observers.SerializedSubscriber;
+import rx.plugins.RxJavaHooks;
 
 public final class OperatorWithLatestFromMany<T, R> implements OnSubscribe<R> {
     final Observable<T> main;
@@ -144,7 +144,7 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable e) {
             if (done) {
-                RxJavaPluginUtils.handleException(e);
+                RxJavaHooks.onError(e);
                 return;
             }
             done = true;
diff --git a/src/main/java/rx/internal/operators/OperatorZip.java b/src/main/java/rx/internal/operators/OperatorZip.java
index 805642e9a6..b3e3738737 100644
--- a/src/main/java/rx/internal/operators/OperatorZip.java
+++ b/src/main/java/rx/internal/operators/OperatorZip.java
@@ -17,23 +17,10 @@
 
 import java.util.concurrent.atomic.AtomicLong;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.Operator;
-import rx.Observer;
-import rx.Producer;
-import rx.Subscriber;
-import rx.exceptions.Exceptions;
-import rx.exceptions.MissingBackpressureException;
-import rx.functions.Func2;
-import rx.functions.Func3;
-import rx.functions.Func4;
-import rx.functions.Func5;
-import rx.functions.Func6;
-import rx.functions.Func7;
-import rx.functions.Func8;
-import rx.functions.Func9;
-import rx.functions.FuncN;
-import rx.functions.Functions;
+import rx.exceptions.*;
+import rx.functions.*;
 import rx.internal.util.RxRingBuffer;
 import rx.subscriptions.CompositeSubscription;
 
diff --git a/src/main/java/rx/internal/operators/OperatorZipIterable.java b/src/main/java/rx/internal/operators/OperatorZipIterable.java
index a90e62f470..b850b49d19 100644
--- a/src/main/java/rx/internal/operators/OperatorZipIterable.java
+++ b/src/main/java/rx/internal/operators/OperatorZipIterable.java
@@ -18,8 +18,8 @@
 import java.util.Iterator;
 
 import rx.Observable.Operator;
-import rx.exceptions.Exceptions;
 import rx.Subscriber;
+import rx.exceptions.Exceptions;
 import rx.functions.Func2;
 import rx.observers.Subscribers;
 
diff --git a/src/main/java/rx/internal/operators/SingleDoAfterTerminate.java b/src/main/java/rx/internal/operators/SingleDoAfterTerminate.java
index ea9986ebac..7a683ecb78 100644
--- a/src/main/java/rx/internal/operators/SingleDoAfterTerminate.java
+++ b/src/main/java/rx/internal/operators/SingleDoAfterTerminate.java
@@ -18,7 +18,7 @@
 import rx.*;
 import rx.exceptions.Exceptions;
 import rx.functions.Action0;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Execute an action after onSuccess or onError has been delivered.
@@ -75,7 +75,7 @@ void doAction() {
                 action.call();
             } catch (Throwable ex) {
                 Exceptions.throwIfFatal(ex);
-                RxJavaPluginUtils.handleException(ex);
+                RxJavaHooks.onError(ex);
             }
         }
     }
diff --git a/src/main/java/rx/internal/operators/SingleOnSubscribeMap.java b/src/main/java/rx/internal/operators/SingleOnSubscribeMap.java
index 78ff4936ff..1c188fd67c 100644
--- a/src/main/java/rx/internal/operators/SingleOnSubscribeMap.java
+++ b/src/main/java/rx/internal/operators/SingleOnSubscribeMap.java
@@ -18,7 +18,7 @@
 import rx.*;
 import rx.exceptions.*;
 import rx.functions.Func1;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Applies a function of your choosing to every item emitted by an {@code Single}, and emits the results of
@@ -77,7 +77,7 @@ public void onSuccess(T t) {
         @Override
         public void onError(Throwable e) {
             if (done) {
-                RxJavaPluginUtils.handleException(e);
+                RxJavaHooks.onError(e);
                 return;
             }
             done = true;
diff --git a/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java b/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
index 3868c2d80d..67cdea7a6a 100644
--- a/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
+++ b/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
@@ -16,8 +16,7 @@
 
 package rx.internal.operators;
 
-import rx.Single;
-import rx.SingleSubscriber;
+import rx.*;
 import rx.exceptions.Exceptions;
 import rx.functions.Func1;
 
diff --git a/src/main/java/rx/internal/util/ObjectPool.java b/src/main/java/rx/internal/util/ObjectPool.java
index 7b22a3e122..ec23c5445b 100644
--- a/src/main/java/rx/internal/util/ObjectPool.java
+++ b/src/main/java/rx/internal/util/ObjectPool.java
@@ -23,6 +23,7 @@
 
 import rx.internal.schedulers.*;
 import rx.internal.util.unsafe.*;
+import rx.plugins.RxJavaHooks;
 
 public abstract class ObjectPool<T> implements SchedulerLifecycle {
     Queue<T> pool;
@@ -130,7 +131,7 @@ public void run() {
         
                 }, validationInterval, validationInterval, TimeUnit.SECONDS);
             } catch (RejectedExecutionException ex) {
-                RxJavaPluginUtils.handleException(ex);
+                RxJavaHooks.onError(ex);
                 break;
             }
             if (!periodicTask.compareAndSet(null, f)) {
diff --git a/src/main/java/rx/internal/util/RxJavaPluginUtils.java b/src/main/java/rx/internal/util/RxJavaPluginUtils.java
deleted file mode 100644
index e54eb1fd69..0000000000
--- a/src/main/java/rx/internal/util/RxJavaPluginUtils.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- *
- * 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 rx.internal.util;
-
-import rx.plugins.RxJavaHooks;
-
-public final class RxJavaPluginUtils {
-
-    /** Utility class. */
-    private RxJavaPluginUtils() {
-        throw new IllegalStateException("No instances!");
-    }
-    
-    public static void handleException(Throwable e) {
-        try {
-            RxJavaHooks.onError(e);
-        } catch (Throwable pluginException) {
-            handlePluginException(pluginException);
-        }
-    }
-
-    private static void handlePluginException(Throwable pluginException) {
-        /*
-         * We don't want errors from the plugin to affect normal flow.
-         * Since the plugin should never throw this is a safety net
-         * and will complain loudly to System.err so it gets fixed.
-         */
-        System.err.println("RxJavaErrorHandler threw an Exception. It shouldn't. => " + pluginException.getMessage()); // NOPMD 
-        pluginException.printStackTrace(); // NOPMD 
-    }
-    
-}
diff --git a/src/main/java/rx/internal/util/SynchronizedQueue.java b/src/main/java/rx/internal/util/SynchronizedQueue.java
index 5b0795aef6..895bc3e26f 100644
--- a/src/main/java/rx/internal/util/SynchronizedQueue.java
+++ b/src/main/java/rx/internal/util/SynchronizedQueue.java
@@ -115,11 +115,7 @@ public boolean equals(Object obj) {
             return false;
         }
         SynchronizedQueue<?> other = (SynchronizedQueue<?>) obj;
-        if (list == null) {
-            if (other.list != null) {
-                return false;
-            }
-        } else if (!list.equals(other.list)) {
+        if (!list.equals(other.list)) {
             return false;
         }
         return true;
diff --git a/src/main/java/rx/internal/util/UtilityFunctions.java b/src/main/java/rx/internal/util/UtilityFunctions.java
index cf97621de2..3bf6a9060c 100644
--- a/src/main/java/rx/internal/util/UtilityFunctions.java
+++ b/src/main/java/rx/internal/util/UtilityFunctions.java
@@ -12,26 +12,12 @@
  */
 package rx.internal.util;
 
-import java.util.Collections;
-
-import rx.functions.Func0;
 import rx.functions.Func1;
-import rx.functions.Func2;
-import rx.functions.Func3;
-import rx.functions.Func4;
-import rx.functions.Func5;
-import rx.functions.Func6;
-import rx.functions.Func7;
-import rx.functions.Func8;
-import rx.functions.Func9;
-import rx.functions.FuncN;
 
 /**
  * Utility functions for internal use that we don't want part of the public API. 
  */
 public final class UtilityFunctions {
-    @SuppressWarnings("rawtypes")
-    private static final NullFunction NULL_FUNCTION = new NullFunction();
 
     /** Utility class. */
     private UtilityFunctions() {
@@ -90,94 +76,4 @@ public Boolean call(Object o) {
             return false;
         }
     }
-
-    /**
-     * Returns a function that merely returns {@code null}, without side effects.
-     *
-     * @param <T0> the first argument type
-     * @param <T1> the second argument type
-     * @param <T2> the third argument type
-     * @param <T3> the fourth argument type
-     * @param <T4> the fifth argument type
-     * @param <T5> the sixth argument type
-     * @param <T6> the seventh argument type
-     * @param <T7> the eighth argument type
-     * @param <T8> the ninth argument type
-     * @param <T9> the tenth argument type
-     * @param <R> the result type
-     * @return a function that returns {@code null}
-     */
-    @SuppressWarnings("unchecked")
-    public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> returnNull() {
-        return NULL_FUNCTION;
-    }
-
-    static final class NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> implements
-            Func0<R>,
-            Func1<T0, R>,
-            Func2<T0, T1, R>,
-            Func3<T0, T1, T2, R>,
-            Func4<T0, T1, T2, T3, R>,
-            Func5<T0, T1, T2, T3, T4, R>,
-            Func6<T0, T1, T2, T3, T4, T5, R>,
-            Func7<T0, T1, T2, T3, T4, T5, T6, R>,
-            Func8<T0, T1, T2, T3, T4, T5, T6, T7, R>,
-            Func9<T0, T1, T2, T3, T4, T5, T6, T7, T8, R>,
-            FuncN<R> {
-
-        @Override
-        public R call() {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8, T8 t9) {
-            return null;
-        }
-
-        @Override
-        public R call(Object... args) {
-            return null;
-        }
-    }
 }
diff --git a/src/main/java/rx/observers/AsyncCompletableSubscriber.java b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
index 67ebf8a283..488fc27f26 100644
--- a/src/main/java/rx/observers/AsyncCompletableSubscriber.java
+++ b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
@@ -20,7 +20,7 @@
 import rx.Completable.CompletableSubscriber;
 import rx.Subscription;
 import rx.annotations.Experimental;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.plugins.RxJavaHooks;
 
 /**
  * An abstract base class for CompletableSubscriber implementations that want to expose an unsubscription
@@ -74,7 +74,7 @@ public final void onSubscribe(Subscription d) {
         if (!upstream.compareAndSet(null, d)) {
             d.unsubscribe();
             if (upstream.get() != UNSUBSCRIBED) {
-                RxJavaPluginUtils.handleException(new IllegalStateException("Subscription already set!"));
+                RxJavaHooks.onError(new IllegalStateException("Subscription already set!"));
             }
         } else {
             onStart();
diff --git a/src/main/java/rx/observers/Observers.java b/src/main/java/rx/observers/Observers.java
index 864d98fbc1..0fdb4fcc01 100644
--- a/src/main/java/rx/observers/Observers.java
+++ b/src/main/java/rx/observers/Observers.java
@@ -17,8 +17,7 @@
 
 import rx.Observer;
 import rx.exceptions.OnErrorNotImplementedException;
-import rx.functions.Action0;
-import rx.functions.Action1;
+import rx.functions.*;
 
 /**
  * Helper methods and utilities for creating and working with {@link Observer} objects.
diff --git a/src/main/java/rx/observers/SafeCompletableSubscriber.java b/src/main/java/rx/observers/SafeCompletableSubscriber.java
index 12258115c7..80f9abac2d 100644
--- a/src/main/java/rx/observers/SafeCompletableSubscriber.java
+++ b/src/main/java/rx/observers/SafeCompletableSubscriber.java
@@ -19,7 +19,7 @@
 import rx.Subscription;
 import rx.annotations.Experimental;
 import rx.exceptions.*;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Wraps another CompletableSubscriber and handles exceptions thrown
@@ -56,7 +56,7 @@ public void onCompleted() {
 
     @Override
     public void onError(Throwable e) {
-        RxJavaPluginUtils.handleException(e);
+        RxJavaHooks.onError(e);
         if (done) {
             return;
         }
diff --git a/src/main/java/rx/observers/SafeSubscriber.java b/src/main/java/rx/observers/SafeSubscriber.java
index 78a39e78f2..b7bc17120b 100644
--- a/src/main/java/rx/observers/SafeSubscriber.java
+++ b/src/main/java/rx/observers/SafeSubscriber.java
@@ -18,13 +18,8 @@
 import java.util.Arrays;
 
 import rx.Subscriber;
-import rx.exceptions.CompositeException;
-import rx.exceptions.Exceptions;
-import rx.exceptions.OnCompletedFailedException;
-import rx.exceptions.OnErrorFailedException;
-import rx.exceptions.OnErrorNotImplementedException;
-import rx.exceptions.UnsubscribeFailedException;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.exceptions.*;
+import rx.plugins.RxJavaHooks;
 
 /**
  * {@code SafeSubscriber} is a wrapper around {@code Subscriber} that ensures that the {@code Subscriber}
@@ -86,7 +81,7 @@ public void onCompleted() {
                 // we handle here instead of another method so we don't add stacks to the frame
                 // which can prevent it from being able to handle StackOverflow
                 Exceptions.throwIfFatal(e);
-                RxJavaPluginUtils.handleException(e);
+                RxJavaHooks.onError(e);
                 throw new OnCompletedFailedException(e.getMessage(), e);
             } finally { // NOPMD 
                 try {
@@ -94,7 +89,7 @@ public void onCompleted() {
                     // and we throw an UnsubscribeFailureException.
                     unsubscribe();
                 } catch (Throwable e) {
-                    RxJavaPluginUtils.handleException(e);
+                    RxJavaHooks.onError(e);
                     throw new UnsubscribeFailedException(e.getMessage(), e);
                 }
             }
@@ -152,7 +147,7 @@ public void onNext(T args) {
      * @see <a href="https://github.com/ReactiveX/RxJava/issues/630">the report of this bug</a>
      */
     protected void _onError(Throwable e) { // NOPMD 
-        RxJavaPluginUtils.handleException(e);
+        RxJavaHooks.onError(e);
         try {
             actual.onError(e);
         } catch (OnErrorNotImplementedException e2) { // NOPMD 
@@ -170,7 +165,7 @@ protected void _onError(Throwable e) { // NOPMD
             try {
                 unsubscribe();
             } catch (Throwable unsubscribeException) {
-                RxJavaPluginUtils.handleException(unsubscribeException);
+                RxJavaHooks.onError(unsubscribeException);
                 throw new OnErrorNotImplementedException("Observer.onError not implemented and error while unsubscribing.", new CompositeException(Arrays.asList(e, unsubscribeException))); // NOPMD 
             }
             throw e2;
@@ -180,11 +175,11 @@ protected void _onError(Throwable e) { // NOPMD
              * 
              * https://github.com/ReactiveX/RxJava/issues/198
              */
-            RxJavaPluginUtils.handleException(e2);
+            RxJavaHooks.onError(e2);
             try {
                 unsubscribe();
             } catch (Throwable unsubscribeException) {
-                RxJavaPluginUtils.handleException(unsubscribeException);
+                RxJavaHooks.onError(unsubscribeException);
                 throw new OnErrorFailedException("Error occurred when trying to propagate error to Observer.onError and during unsubscription.", new CompositeException(Arrays.asList(e, e2, unsubscribeException)));
             }
 
@@ -194,7 +189,7 @@ protected void _onError(Throwable e) { // NOPMD
         try {
             unsubscribe();
         } catch (Throwable unsubscribeException) {
-            RxJavaPluginUtils.handleException(unsubscribeException);
+            RxJavaHooks.onError(unsubscribeException);
             throw new OnErrorFailedException(unsubscribeException);
         }
     }
diff --git a/src/main/java/rx/observers/SerializedSubscriber.java b/src/main/java/rx/observers/SerializedSubscriber.java
index 0b16549da3..e5d05f24a2 100644
--- a/src/main/java/rx/observers/SerializedSubscriber.java
+++ b/src/main/java/rx/observers/SerializedSubscriber.java
@@ -15,8 +15,7 @@
  */
 package rx.observers;
 
-import rx.Observer;
-import rx.Subscriber;
+import rx.*;
 
 /**
  * Enforces single-threaded, serialized, ordered execution of {@link #onNext}, {@link #onCompleted}, and
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index 34f58a4947..0adb0af9e9 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -223,8 +223,18 @@ public static boolean isLockdown() {
     public static void onError(Throwable ex) {
         Action1<Throwable> f = onError;
         if (f != null) {
+            try {
             f.call(ex);
-            return;
+                return;
+            } catch (Throwable pluginException) {
+                /*
+                 * We don't want errors from the plugin to affect normal flow.
+                 * Since the plugin should never throw this is a safety net
+                 * and will complain loudly to System.err so it gets fixed.
+                 */
+                System.err.println("RxJavaErrorHandler threw an Exception. It shouldn't. => " + pluginException.getMessage()); // NOPMD 
+                pluginException.printStackTrace(); // NOPMD 
+            }
         }
         Thread current = Thread.currentThread();
         current.getUncaughtExceptionHandler().uncaughtException(current, ex);
diff --git a/src/main/java/rx/subjects/ReplaySubject.java b/src/main/java/rx/subjects/ReplaySubject.java
index 63d3001414..52dffd5752 100644
--- a/src/main/java/rx/subjects/ReplaySubject.java
+++ b/src/main/java/rx/subjects/ReplaySubject.java
@@ -25,7 +25,7 @@
 import rx.annotations.Beta;
 import rx.exceptions.Exceptions;
 import rx.internal.operators.BackpressureUtils;
-import rx.internal.util.RxJavaPluginUtils;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.Schedulers;
 
 /**
@@ -568,7 +568,7 @@ public void next(T t) {
         @Override
         public void error(Throwable e) {
             if (done) {
-                RxJavaPluginUtils.handleException(e);
+                RxJavaHooks.onError(e);
                 return;
             }
             error = e;
diff --git a/src/test/java/rx/internal/operators/OperatorCountTest.java b/src/test/java/rx/internal/operators/OperatorCountTest.java
new file mode 100644
index 0000000000..0a6d56683b
--- /dev/null
+++ b/src/test/java/rx/internal/operators/OperatorCountTest.java
@@ -0,0 +1,36 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import org.junit.*;
+
+import rx.Observable;
+
+public class OperatorCountTest {
+
+    @Test
+    public void simple() {
+        Assert.assertEquals(0, Observable.empty().count().toBlocking().last().intValue());
+        Assert.assertEquals(0L, Observable.empty().countLong().toBlocking().last().intValue());
+
+        Assert.assertEquals(1, Observable.just(1).count().toBlocking().last().intValue());
+        Assert.assertEquals(1L, Observable.just(1).countLong().toBlocking().last().intValue());
+
+        Assert.assertEquals(10, Observable.range(1, 10).count().toBlocking().last().intValue());
+        Assert.assertEquals(10L, Observable.range(1, 10).countLong().toBlocking().last().intValue());
+
+    }
+}
diff --git a/src/test/java/rx/internal/util/ExceptionUtilsTest.java b/src/test/java/rx/internal/util/ExceptionUtilsTest.java
new file mode 100644
index 0000000000..73400f9069
--- /dev/null
+++ b/src/test/java/rx/internal/util/ExceptionUtilsTest.java
@@ -0,0 +1,54 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.util;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.*;
+
+import rx.exceptions.TestException;
+
+public class ExceptionUtilsTest {
+    AtomicReference<Throwable> error = new AtomicReference<Throwable>();
+
+    @Test
+    public void addToTerminatedFalse() {
+        ExceptionsUtils.terminate(error);
+        Assert.assertFalse(ExceptionsUtils.addThrowable(error, new TestException()));
+    }
+
+    @Test
+    public void doubleTerminate() {
+        Assert.assertNull(ExceptionsUtils.terminate(error));
+        Assert.assertNotNull(ExceptionsUtils.terminate(error));
+    }
+
+    @Test
+    public void isTerminated() {
+        Assert.assertFalse(ExceptionsUtils.isTerminated(error));
+        Assert.assertFalse(ExceptionsUtils.isTerminated(error.get()));
+
+        ExceptionsUtils.addThrowable(error, new TestException());
+
+        Assert.assertFalse(ExceptionsUtils.isTerminated(error));
+        Assert.assertFalse(ExceptionsUtils.isTerminated(error.get()));
+        
+        ExceptionsUtils.terminate(error);
+        
+        Assert.assertTrue(ExceptionsUtils.isTerminated(error));
+        Assert.assertTrue(ExceptionsUtils.isTerminated(error.get()));
+    }
+}
diff --git a/src/test/java/rx/internal/util/PlatformDependentTest.java b/src/test/java/rx/internal/util/PlatformDependentTest.java
new file mode 100644
index 0000000000..af8e5fd2de
--- /dev/null
+++ b/src/test/java/rx/internal/util/PlatformDependentTest.java
@@ -0,0 +1,43 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.util;
+
+import static org.junit.Assert.fail;
+
+import java.lang.reflect.*;
+
+import org.junit.Test;
+
+public class PlatformDependentTest {
+    @Test
+    public void testNotInstantiable() {
+        try {
+            Constructor<?> c = PlatformDependent.class.getDeclaredConstructor();
+            c.setAccessible(true);
+            Object instance = c.newInstance();
+            fail("Could instantiate Actions! " + instance);
+        } catch (NoSuchMethodException ex) {
+            ex.printStackTrace();
+        } catch (InvocationTargetException ex) {
+            ex.printStackTrace();
+        } catch (InstantiationException ex) {
+            ex.printStackTrace();
+        } catch (IllegalAccessException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+}
diff --git a/src/test/java/rx/internal/util/SubscriptionListTest.java b/src/test/java/rx/internal/util/SubscriptionListTest.java
index 614b55445d..79475e60f4 100644
--- a/src/test/java/rx/internal/util/SubscriptionListTest.java
+++ b/src/test/java/rx/internal/util/SubscriptionListTest.java
@@ -23,11 +23,12 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import org.junit.Test;
+import org.junit.*;
 
 import rx.Subscription;
 import rx.exceptions.CompositeException;
 import rx.internal.util.SubscriptionList;
+import rx.subscriptions.Subscriptions;
 
 public class SubscriptionListTest {
 
@@ -282,4 +283,54 @@ public void run() {
         // we should have only unsubscribed once
         assertEquals(1, counter.get());
     }
+    
+    @Test
+    public void removeWhenEmpty() {
+        SubscriptionList slist = new SubscriptionList();
+        Subscription s = Subscriptions.empty();
+        
+        slist.remove(s);
+        
+        Assert.assertFalse(s.isUnsubscribed());
+    }
+
+    @Test
+    public void removeNotIn() {
+        SubscriptionList slist = new SubscriptionList();
+        Subscription s0 = Subscriptions.empty();
+        slist.add(s0);
+        
+        Assert.assertTrue(slist.hasSubscriptions());
+        
+        Subscription s = Subscriptions.empty();
+        
+        slist.remove(s);
+        
+        Assert.assertFalse(s.isUnsubscribed());
+        
+        slist.clear();
+        
+        Assert.assertTrue(s0.isUnsubscribed());
+
+        Assert.assertFalse(slist.hasSubscriptions());
+    }
+
+    @Test
+    public void unsubscribeClear() {
+        SubscriptionList slist = new SubscriptionList();
+        
+        Assert.assertFalse(slist.hasSubscriptions());
+        
+        Subscription s0 = Subscriptions.empty();
+        slist.add(s0);
+        
+        slist.unsubscribe();
+        
+        Assert.assertTrue(s0.isUnsubscribed());
+
+        Assert.assertFalse(slist.hasSubscriptions());
+
+        slist.clear();
+    }
+
 }
diff --git a/src/test/java/rx/internal/util/SynchronizedQueueTest.java b/src/test/java/rx/internal/util/SynchronizedQueueTest.java
index aea871711a..82c67d3285 100644
--- a/src/test/java/rx/internal/util/SynchronizedQueueTest.java
+++ b/src/test/java/rx/internal/util/SynchronizedQueueTest.java
@@ -18,14 +18,138 @@
 
 import static org.junit.Assert.assertTrue;
 
-import org.junit.Test;
+import java.util.*;
+
+import org.junit.*;
 
 public class SynchronizedQueueTest {
+    SynchronizedQueue<Object> q = new SynchronizedQueue<Object>();
     
     @Test
     public void testEquals() {
-         SynchronizedQueue<Object> q = new SynchronizedQueue<Object>();
+         
          assertTrue(q.equals(q));
     }
 
+    @Test
+    public void contains() {
+        q.offer(1);
+        Assert.assertTrue(q.add(2));
+        
+        Assert.assertEquals(2, q.size());
+        Assert.assertTrue(q.contains(1));
+        Assert.assertTrue(q.contains(2));
+        Assert.assertFalse(q.contains(3));
+    }
+    
+    @Test
+    public void iterator() {
+        q.offer(1);
+        
+        Assert.assertEquals(1, q.iterator().next());
+    }
+
+    @Test
+    public void remove() {
+        q.offer(1);
+        q.offer(2);
+        q.offer(3);
+        
+        Assert.assertTrue(q.remove(2));
+        Assert.assertFalse(q.remove(2));
+    }
+    
+    @Test
+    public void addAllContainsAll() {
+        q.addAll(Arrays.asList(1, 2, 3, 4));
+        
+        q.removeAll(Arrays.asList(2, 3));
+        
+        Assert.assertEquals(2, q.size());
+        Assert.assertTrue(q.contains(1));
+        Assert.assertFalse(q.contains(2));
+        Assert.assertFalse(q.contains(3));
+        Assert.assertTrue(q.contains(4));
+        
+        Assert.assertTrue(q.containsAll(Arrays.asList(1, 4)));
+        Assert.assertFalse(q.containsAll(Arrays.asList(2, 3)));
+    }
+
+    @Test
+    public void retainAll() {
+        q.addAll(Arrays.asList(1, 2, 3, 4));
+        
+        q.retainAll(Arrays.asList(2, 3));
+        
+        Assert.assertEquals(2, q.size());
+        Assert.assertFalse(q.contains(1));
+        Assert.assertTrue(q.contains(2));
+        Assert.assertTrue(q.contains(3));
+        Assert.assertFalse(q.contains(4));
+    }
+
+    @Test
+    public void clear() {
+        q.addAll(Arrays.asList(1, 2, 3, 4));
+        
+        q.clear();
+        
+        Assert.assertEquals(0, q.size());
+        Assert.assertTrue(q.isEmpty());
+    }
+
+    @Test
+    public void toStringValue() {
+        q.offer(1);
+        
+        Assert.assertEquals("[1]", q.toString());
+    }
+    
+    @Test
+    public void equalsTo() {
+        q.offer(1);
+        
+        SynchronizedQueue<Integer> q2 = new SynchronizedQueue<Integer>();
+        q2.offer(1);
+
+        SynchronizedQueue<Integer> q3 = new SynchronizedQueue<Integer>();
+        q3.offer(2);
+
+        Assert.assertEquals(q, q2);
+        Assert.assertEquals(q.hashCode(), q2.hashCode());
+        Assert.assertNotEquals(q, q3);
+        
+        Assert.assertFalse(q.equals(null));
+        Assert.assertFalse(q.equals(1));
+
+        Assert.assertEquals(q, q.clone());
+
+    }
+    
+    @Test
+    public void toArray() {
+        q.offer(1);
+        
+        Object[] a = q.toArray();
+        
+        Object[] b = q.toArray(new Integer[1]);
+        
+        Assert.assertEquals(1, a[0]);
+        Assert.assertEquals(1, b[0]);
+    }
+    
+    @Test
+    public void peekElement() {
+        q.offer(1);
+        
+        Assert.assertEquals(1, q.peek());
+        Assert.assertEquals(1, q.element());
+        Assert.assertEquals(1, q.remove());
+        try {
+            q.element();
+            Assert.fail("Failed to throw on empty queue");
+        } catch (NoSuchElementException ex) {
+            // expected
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/util/UtilityFunctionsTest.java b/src/test/java/rx/internal/util/UtilityFunctionsTest.java
new file mode 100644
index 0000000000..32bd930501
--- /dev/null
+++ b/src/test/java/rx/internal/util/UtilityFunctionsTest.java
@@ -0,0 +1,43 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.util;
+
+import static org.junit.Assert.fail;
+
+import java.lang.reflect.*;
+
+import org.junit.Test;
+
+public class UtilityFunctionsTest {
+    @Test
+    public void testNotInstantiable() {
+        try {
+            Constructor<?> c = UtilityFunctions.class.getDeclaredConstructor();
+            c.setAccessible(true);
+            Object instance = c.newInstance();
+            fail("Could instantiate Actions! " + instance);
+        } catch (NoSuchMethodException ex) {
+            ex.printStackTrace();
+        } catch (InvocationTargetException ex) {
+            ex.printStackTrace();
+        } catch (InstantiationException ex) {
+            ex.printStackTrace();
+        } catch (IllegalAccessException ex) {
+            ex.printStackTrace();
+        }
+    }
+    
+}

From 66815b4455f9b597e479e45162ff05eaf50d860b Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Sun, 26 Jun 2016 12:19:06 +0200
Subject: [PATCH 088/263] 1.x: run Findbugs on main only (#4131)

---
 build.gradle | 1 +
 1 file changed, 1 insertion(+)

diff --git a/build.gradle b/build.gradle
index 7620a876d6..7b66147496 100644
--- a/build.gradle
+++ b/build.gradle
@@ -124,6 +124,7 @@ findbugs {
     toolVersion = '3.0.1'
     effort = 'max'
     reportLevel = 'low'
+    sourceSets = [sourceSets.main]
 }
 
 findbugsMain {

From 5c747577e910b5eda657bc9f825914965fb2f1c4 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Mon, 27 Jun 2016 07:13:13 +0200
Subject: [PATCH 089/263] 1.x: Test all private Constructors (#4125)

* 1.x: Test all private Constructors

* Revert exception type and message back
---
 build.gradle                                  |  1 +
 .../java/rx/internal/util/unsafe/Pow2.java    |  2 +-
 .../rx/internal/util/unsafe/UnsafeAccess.java |  2 +-
 src/test/java/rx/EventStreamTest.java         | 27 +++++++++++++++++++
 .../java/rx/exceptions/ExceptionsTest.java    |  6 +++++
 src/test/java/rx/functions/ActionsTest.java   | 25 +++++------------
 src/test/java/rx/functions/FunctionsTest.java | 24 +++++------------
 .../operators/BackpressureUtilsTest.java      |  7 +++++
 .../operators/BlockingOperatorLatestTest.java |  7 +++++
 .../BlockingOperatorMostRecentTest.java       |  7 +++++
 .../operators/BlockingOperatorNextTest.java   |  7 +++++
 .../BlockingOperatorToFutureTest.java         |  6 +++++
 .../BlockingOperatorToIteratorTest.java       |  6 +++++
 .../OnSubscribeToObservableFutureTest.java    |  6 +++++
 .../operators/OperatorSequenceEqualTest.java  |  6 +++++
 .../operators/SingleOperatorZipTest.java      | 27 +++++++++++++++++++
 .../internal/util/PlatformDependentTest.java  | 22 +++------------
 .../internal/util/UtilityFunctionsTest.java   | 27 ++++++-------------
 .../rx/internal/util/unsafe/Pow2Test.java     | 27 +++++++++++++++++++
 .../util/unsafe/UnsafeAccessTest.java         | 27 +++++++++++++++++++
 src/test/java/rx/observers/ObserversTest.java | 19 +++----------
 .../java/rx/observers/SubscribersTest.java    | 19 +++----------
 src/test/java/rx/plugins/RxJavaHooksTest.java |  7 +++++
 .../rx/subscriptions/SubscriptionsTest.java   |  6 +++++
 24 files changed, 214 insertions(+), 106 deletions(-)
 create mode 100644 src/test/java/rx/EventStreamTest.java
 create mode 100644 src/test/java/rx/internal/operators/SingleOperatorZipTest.java
 create mode 100644 src/test/java/rx/internal/util/unsafe/Pow2Test.java
 create mode 100644 src/test/java/rx/internal/util/unsafe/UnsafeAccessTest.java

diff --git a/build.gradle b/build.gradle
index 7b66147496..b83de64585 100644
--- a/build.gradle
+++ b/build.gradle
@@ -27,6 +27,7 @@ dependencies {
     testCompile 'junit:junit:4.12'
     testCompile 'org.mockito:mockito-core:1.10.19'
     testCompile 'com.google.guava:guava:19.0'
+    testCompile 'com.pushtorefresh.java-private-constructor-checker:checker:1.2.0'
 
     perfCompile 'org.openjdk.jmh:jmh-core:1.11.3'
     perfCompile 'org.openjdk.jmh:jmh-generator-annprocess:1.11.3'
diff --git a/src/main/java/rx/internal/util/unsafe/Pow2.java b/src/main/java/rx/internal/util/unsafe/Pow2.java
index cbbd9c9c87..528560e6cd 100644
--- a/src/main/java/rx/internal/util/unsafe/Pow2.java
+++ b/src/main/java/rx/internal/util/unsafe/Pow2.java
@@ -41,4 +41,4 @@ public static int roundToPowerOfTwo(final int value) {
     public static boolean isPowerOfTwo(final int value) {
         return (value & (value - 1)) == 0;
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java b/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
index d45d5d4946..d3b88cf9cd 100644
--- a/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
+++ b/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
@@ -117,4 +117,4 @@ public static long addressOf(Class<?> clazz, String fieldName) {
             throw ie;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/rx/EventStreamTest.java b/src/test/java/rx/EventStreamTest.java
new file mode 100644
index 0000000000..4dc3c1d5fc
--- /dev/null
+++ b/src/test/java/rx/EventStreamTest.java
@@ -0,0 +1,27 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx;
+
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
+import org.junit.Test;
+
+public class EventStreamTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(EventStream.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
+}
diff --git a/src/test/java/rx/exceptions/ExceptionsTest.java b/src/test/java/rx/exceptions/ExceptionsTest.java
index c325ab81fc..2291621f0b 100644
--- a/src/test/java/rx/exceptions/ExceptionsTest.java
+++ b/src/test/java/rx/exceptions/ExceptionsTest.java
@@ -18,6 +18,8 @@
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
@@ -33,6 +35,10 @@
 import rx.subjects.PublishSubject;
 
 public class ExceptionsTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(Exceptions.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
 
     @Test(expected = OnErrorNotImplementedException.class)
     public void testOnErrorNotImplementedIsThrown() {
diff --git a/src/test/java/rx/functions/ActionsTest.java b/src/test/java/rx/functions/ActionsTest.java
index 8ffecb97ca..664c94790d 100644
--- a/src/test/java/rx/functions/ActionsTest.java
+++ b/src/test/java/rx/functions/ActionsTest.java
@@ -15,13 +15,15 @@
  */
 package rx.functions;
 
-import static org.junit.Assert.*;
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
+import org.junit.Test;
 
-import java.lang.reflect.*;
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicLong;
 
-import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 
 public class ActionsTest {
 
@@ -271,20 +273,7 @@ public void call(Object... args) {
     }
     
     @Test
-    public void testNotInstantiable() {
-        try {
-            Constructor<?> c = Actions.class.getDeclaredConstructor();
-            c.setAccessible(true);
-            Object instance = c.newInstance();
-            fail("Could instantiate Actions! " + instance);
-        } catch (NoSuchMethodException ex) {
-            ex.printStackTrace();
-        } catch (InvocationTargetException ex) {
-            ex.printStackTrace();
-        } catch (InstantiationException ex) {
-            ex.printStackTrace();
-        } catch (IllegalAccessException ex) {
-            ex.printStackTrace();
-        }
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(Actions.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
     }
 }
diff --git a/src/test/java/rx/functions/FunctionsTest.java b/src/test/java/rx/functions/FunctionsTest.java
index 1d2cc95374..650713cd8e 100644
--- a/src/test/java/rx/functions/FunctionsTest.java
+++ b/src/test/java/rx/functions/FunctionsTest.java
@@ -15,31 +15,19 @@
  */
 package rx.functions;
 
-import static org.junit.Assert.*;
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
+import org.junit.Test;
 
-import java.lang.reflect.*;
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicLong;
 
-import org.junit.Test;
+import static org.junit.Assert.assertEquals;
 
 public class FunctionsTest {
     @Test
-    public void testNotInstantiable() {
-        try {
-            Constructor<?> c = Functions.class.getDeclaredConstructor();
-            c.setAccessible(true);
-            Object instance = c.newInstance();
-            fail("Could instantiate Actions! " + instance);
-        } catch (NoSuchMethodException ex) {
-            ex.printStackTrace();
-        } catch (InvocationTargetException ex) {
-            ex.printStackTrace();
-        } catch (InstantiationException ex) {
-            ex.printStackTrace();
-        } catch (IllegalAccessException ex) {
-            ex.printStackTrace();
-        }
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(Functions.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
     }
     
     @Test(expected = RuntimeException.class)
diff --git a/src/test/java/rx/internal/operators/BackpressureUtilsTest.java b/src/test/java/rx/internal/operators/BackpressureUtilsTest.java
index 0bc7f542bf..e8bc8fe0b7 100644
--- a/src/test/java/rx/internal/operators/BackpressureUtilsTest.java
+++ b/src/test/java/rx/internal/operators/BackpressureUtilsTest.java
@@ -15,10 +15,17 @@
  */
 package rx.internal.operators;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import org.junit.Test;
 import static org.junit.Assert.*;
 
 public class BackpressureUtilsTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(BackpressureUtils.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
+
     @Test
     public void testAddCap() {
         assertEquals(2L, BackpressureUtils.addCap(1, 1));
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java b/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
index 2c586019ed..6b9680f5fd 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
@@ -15,6 +15,8 @@
  */
 package rx.internal.operators;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.concurrent.TimeUnit;
@@ -29,6 +31,11 @@
 import rx.subjects.PublishSubject;
 
 public class BlockingOperatorLatestTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(BlockingOperatorLatest.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
+
     @Test(timeout = 1000)
     public void testSimple() {
         TestScheduler scheduler = new TestScheduler();
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java b/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java
index 3f377cffb1..68d545f6c0 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java
@@ -20,6 +20,8 @@
 import static org.junit.Assert.assertTrue;
 import static rx.internal.operators.BlockingOperatorMostRecent.mostRecent;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import java.util.Iterator;
 import java.util.concurrent.TimeUnit;
 
@@ -34,6 +36,11 @@
 import rx.subjects.Subject;
 
 public class BlockingOperatorMostRecentTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(BlockingOperatorMostRecent.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
+
     @Test
     public void testMostRecentNull() {
         assertEquals(null, Observable.<Void>never().toBlocking().mostRecent(null).iterator().next());
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
index 4b44f5d739..8c126a81e1 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
@@ -15,6 +15,8 @@
  */
 package rx.internal.operators;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -70,6 +72,11 @@ public void run() {
         }.start();
     }
 
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(BlockingOperatorNext.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
+
     @Test
     public void testNext() {
         Subject<String, String> obs = PublishSubject.create();
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java b/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
index 96edb2ced8..998322785f 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
@@ -20,6 +20,8 @@
 import static org.junit.Assert.fail;
 import static rx.internal.operators.BlockingOperatorToFuture.toFuture;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import java.util.List;
 import java.util.NoSuchElementException;
 import java.util.concurrent.CancellationException;
@@ -35,6 +37,10 @@
 import rx.exceptions.TestException;
 
 public class BlockingOperatorToFutureTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(BlockingOperatorToFuture.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
 
     @Test
     public void testToFuture() throws InterruptedException, ExecutionException {
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java b/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
index 4ed030660b..dfad856a62 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
@@ -18,6 +18,8 @@
 import static org.junit.Assert.assertEquals;
 import static rx.internal.operators.BlockingOperatorToIterator.toIterator;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import java.util.Iterator;
 
 import org.junit.Test;
@@ -30,6 +32,10 @@
 import rx.internal.util.RxRingBuffer;
 
 public class BlockingOperatorToIteratorTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(BlockingOperatorToIterator.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
 
     @Test
     public void testToIterator() {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
index 9734cc4c41..362867a4a7 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
@@ -19,6 +19,8 @@
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.*;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
@@ -29,6 +31,10 @@
 import rx.schedulers.Schedulers;
 
 public class OnSubscribeToObservableFutureTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(OnSubscribeToObservableFuture.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
 
     @Test
     public void testSuccess() throws Exception {
diff --git a/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java b/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java
index e0fa617bb8..86d7e450fa 100644
--- a/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java
@@ -20,6 +20,8 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import org.junit.Test;
 import org.mockito.InOrder;
 
@@ -29,6 +31,10 @@
 import rx.functions.Func2;
 
 public class OperatorSequenceEqualTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(OperatorSequenceEqual.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
 
     @Test
     public void test1() {
diff --git a/src/test/java/rx/internal/operators/SingleOperatorZipTest.java b/src/test/java/rx/internal/operators/SingleOperatorZipTest.java
new file mode 100644
index 0000000000..af04971089
--- /dev/null
+++ b/src/test/java/rx/internal/operators/SingleOperatorZipTest.java
@@ -0,0 +1,27 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
+import org.junit.Test;
+
+public class SingleOperatorZipTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(SingleOperatorZip.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
+}
diff --git a/src/test/java/rx/internal/util/PlatformDependentTest.java b/src/test/java/rx/internal/util/PlatformDependentTest.java
index af8e5fd2de..68f653fb64 100644
--- a/src/test/java/rx/internal/util/PlatformDependentTest.java
+++ b/src/test/java/rx/internal/util/PlatformDependentTest.java
@@ -15,29 +15,13 @@
  */
 package rx.internal.util;
 
-import static org.junit.Assert.fail;
-
-import java.lang.reflect.*;
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
 
 import org.junit.Test;
 
 public class PlatformDependentTest {
     @Test
-    public void testNotInstantiable() {
-        try {
-            Constructor<?> c = PlatformDependent.class.getDeclaredConstructor();
-            c.setAccessible(true);
-            Object instance = c.newInstance();
-            fail("Could instantiate Actions! " + instance);
-        } catch (NoSuchMethodException ex) {
-            ex.printStackTrace();
-        } catch (InvocationTargetException ex) {
-            ex.printStackTrace();
-        } catch (InstantiationException ex) {
-            ex.printStackTrace();
-        } catch (IllegalAccessException ex) {
-            ex.printStackTrace();
-        }
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(PlatformDependent.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
     }
-
 }
diff --git a/src/test/java/rx/internal/util/UtilityFunctionsTest.java b/src/test/java/rx/internal/util/UtilityFunctionsTest.java
index 32bd930501..e610d25634 100644
--- a/src/test/java/rx/internal/util/UtilityFunctionsTest.java
+++ b/src/test/java/rx/internal/util/UtilityFunctionsTest.java
@@ -15,29 +15,18 @@
  */
 package rx.internal.util;
 
-import static org.junit.Assert.fail;
-
-import java.lang.reflect.*;
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
 
 import org.junit.Test;
 
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+import static org.junit.Assert.fail;
+
 public class UtilityFunctionsTest {
     @Test
-    public void testNotInstantiable() {
-        try {
-            Constructor<?> c = UtilityFunctions.class.getDeclaredConstructor();
-            c.setAccessible(true);
-            Object instance = c.newInstance();
-            fail("Could instantiate Actions! " + instance);
-        } catch (NoSuchMethodException ex) {
-            ex.printStackTrace();
-        } catch (InvocationTargetException ex) {
-            ex.printStackTrace();
-        } catch (InstantiationException ex) {
-            ex.printStackTrace();
-        } catch (IllegalAccessException ex) {
-            ex.printStackTrace();
-        }
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(UtilityFunctions.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
     }
-    
 }
diff --git a/src/test/java/rx/internal/util/unsafe/Pow2Test.java b/src/test/java/rx/internal/util/unsafe/Pow2Test.java
new file mode 100644
index 0000000000..2b3c9cfaf6
--- /dev/null
+++ b/src/test/java/rx/internal/util/unsafe/Pow2Test.java
@@ -0,0 +1,27 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.util.unsafe;
+
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
+import org.junit.Test;
+
+public class Pow2Test {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(Pow2.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
+}
diff --git a/src/test/java/rx/internal/util/unsafe/UnsafeAccessTest.java b/src/test/java/rx/internal/util/unsafe/UnsafeAccessTest.java
new file mode 100644
index 0000000000..1fd5b09c7a
--- /dev/null
+++ b/src/test/java/rx/internal/util/unsafe/UnsafeAccessTest.java
@@ -0,0 +1,27 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.util.unsafe;
+
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
+import org.junit.Test;
+
+public class UnsafeAccessTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(UnsafeAccess.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
+}
diff --git a/src/test/java/rx/observers/ObserversTest.java b/src/test/java/rx/observers/ObserversTest.java
index 4507306f51..9f125f1e9a 100644
--- a/src/test/java/rx/observers/ObserversTest.java
+++ b/src/test/java/rx/observers/ObserversTest.java
@@ -18,6 +18,8 @@
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import java.io.IOException;
 import java.lang.reflect.*;
 import java.util.Queue;
@@ -32,21 +34,8 @@
 
 public class ObserversTest {
     @Test
-    public void testNotInstantiable() {
-        try {
-            Constructor<?> c = Observers.class.getDeclaredConstructor();
-            c.setAccessible(true);
-            Object instance = c.newInstance();
-            fail("Could instantiate Actions! " + instance);
-        } catch (NoSuchMethodException ex) {
-            ex.printStackTrace();
-        } catch (InvocationTargetException ex) {
-            ex.printStackTrace();
-        } catch (InstantiationException ex) {
-            ex.printStackTrace();
-        } catch (IllegalAccessException ex) {
-            ex.printStackTrace();
-        }
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(Observers.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
     }
     
     @Test
diff --git a/src/test/java/rx/observers/SubscribersTest.java b/src/test/java/rx/observers/SubscribersTest.java
index e0e91d84b0..76c4a0982e 100644
--- a/src/test/java/rx/observers/SubscribersTest.java
+++ b/src/test/java/rx/observers/SubscribersTest.java
@@ -18,6 +18,8 @@
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import java.lang.reflect.*;
 import java.util.concurrent.atomic.*;
 
@@ -30,21 +32,8 @@
 
 public class SubscribersTest {
     @Test
-    public void testNotInstantiable() {
-        try {
-            Constructor<?> c = Subscribers.class.getDeclaredConstructor();
-            c.setAccessible(true);
-            Object instance = c.newInstance();
-            fail("Could instantiate Actions! " + instance);
-        } catch (NoSuchMethodException ex) {
-            ex.printStackTrace();
-        } catch (InvocationTargetException ex) {
-            ex.printStackTrace();
-        } catch (InstantiationException ex) {
-            ex.printStackTrace();
-        } catch (IllegalAccessException ex) {
-            ex.printStackTrace();
-        }
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(Subscribers.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
     }
     
     @Test
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index 2072e72d49..d4e2b81732 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -15,6 +15,8 @@
  */
 package rx.plugins;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import java.lang.reflect.Method;
 
 import org.junit.*;
@@ -36,6 +38,11 @@ public Integer call(Integer t) {
         });
     }
     
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(RxJavaHooks.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
+
     @Test
     public void assemblyTrackingObservable() {
         RxJavaHooks.enableAssemblyTracking();
diff --git a/src/test/java/rx/subscriptions/SubscriptionsTest.java b/src/test/java/rx/subscriptions/SubscriptionsTest.java
index b780942323..5186a87438 100644
--- a/src/test/java/rx/subscriptions/SubscriptionsTest.java
+++ b/src/test/java/rx/subscriptions/SubscriptionsTest.java
@@ -22,12 +22,18 @@
 import static org.mockito.Mockito.verify;
 import static rx.subscriptions.Subscriptions.create;
 
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
 import org.junit.Test;
 
 import rx.Subscription;
 import rx.functions.Action0;
 
 public class SubscriptionsTest {
+    @Test
+    public void constructorShouldBePrivate() {
+        PrivateConstructorChecker.forClass(Subscriptions.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+    }
 
     @Test
     public void testUnsubscribeOnlyOnce() {

From 543990178e92f0c3fbf4ec1b2c58ee412dff8da9 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Mon, 27 Jun 2016 22:58:54 +0200
Subject: [PATCH 090/263] Refactor private constructor checker into a utility
 class. (#4133)

---
 src/test/java/rx/EventStreamTest.java         |  4 +-
 src/test/java/rx/TestUtil.java                | 39 +++++++++++++++++++
 .../java/rx/exceptions/ExceptionsTest.java    | 16 ++------
 src/test/java/rx/functions/ActionsTest.java   | 11 +++---
 src/test/java/rx/functions/FunctionsTest.java | 10 ++---
 .../operators/BackpressureUtilsTest.java      |  7 ++--
 .../operators/BlockingOperatorLatestTest.java | 12 ++----
 .../BlockingOperatorMostRecentTest.java       | 16 +++-----
 .../operators/BlockingOperatorNextTest.java   | 29 +++++---------
 .../BlockingOperatorToFutureTest.java         | 18 +++------
 .../BlockingOperatorToIteratorTest.java       |  7 +---
 .../OnSubscribeToObservableFutureTest.java    |  6 +--
 .../operators/OperatorSequenceEqualTest.java  | 11 ++----
 .../operators/SingleOperatorZipTest.java      |  6 +--
 .../internal/util/PlatformDependentTest.java  |  6 +--
 .../internal/util/UtilityFunctionsTest.java   |  9 +----
 .../rx/internal/util/unsafe/Pow2Test.java     |  6 +--
 .../util/unsafe/UnsafeAccessTest.java         |  6 +--
 src/test/java/rx/observers/ObserversTest.java |  7 +---
 .../java/rx/observers/SubscribersTest.java    |  7 +---
 src/test/java/rx/plugins/RxJavaHooksTest.java |  4 +-
 .../rx/subscriptions/SubscriptionsTest.java   | 13 ++-----
 22 files changed, 111 insertions(+), 139 deletions(-)
 create mode 100644 src/test/java/rx/TestUtil.java

diff --git a/src/test/java/rx/EventStreamTest.java b/src/test/java/rx/EventStreamTest.java
index 4dc3c1d5fc..6599459bb7 100644
--- a/src/test/java/rx/EventStreamTest.java
+++ b/src/test/java/rx/EventStreamTest.java
@@ -15,13 +15,11 @@
  */
 package rx;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import org.junit.Test;
 
 public class EventStreamTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(EventStream.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(EventStream.class);
     }
 }
diff --git a/src/test/java/rx/TestUtil.java b/src/test/java/rx/TestUtil.java
new file mode 100644
index 0000000000..4e315370f7
--- /dev/null
+++ b/src/test/java/rx/TestUtil.java
@@ -0,0 +1,39 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx;
+
+import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+
+/**
+ * Common test utility methods.
+ */
+public enum TestUtil {
+    ;
+    
+    /**
+     * Verifies that the given class has a private constructor that
+     * throws IllegalStateException("No instances!") upon instantiation.
+     * @param clazz the target class to check
+     */
+    public static void checkUtilityClass(Class<?> clazz) {
+        PrivateConstructorChecker
+            .forClass(clazz)
+            .expectedTypeOfException(IllegalStateException.class)
+            .expectedExceptionMessage("No instances!")
+            .check();
+    }
+}
diff --git a/src/test/java/rx/exceptions/ExceptionsTest.java b/src/test/java/rx/exceptions/ExceptionsTest.java
index 2291621f0b..aa4ba21370 100644
--- a/src/test/java/rx/exceptions/ExceptionsTest.java
+++ b/src/test/java/rx/exceptions/ExceptionsTest.java
@@ -15,29 +15,21 @@
  */
 package rx.exceptions;
 
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+import static org.junit.Assert.*;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
 
-import rx.Single;
-import rx.SingleSubscriber;
-import rx.Subscriber;
-import rx.Observable;
-import rx.Observer;
-import rx.functions.Action1;
-import rx.functions.Func1;
+import rx.*;
+import rx.functions.*;
 import rx.observables.GroupedObservable;
 import rx.subjects.PublishSubject;
 
 public class ExceptionsTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(Exceptions.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(Exceptions.class);
     }
 
     @Test(expected = OnErrorNotImplementedException.class)
diff --git a/src/test/java/rx/functions/ActionsTest.java b/src/test/java/rx/functions/ActionsTest.java
index 664c94790d..0e6e2dc5dc 100644
--- a/src/test/java/rx/functions/ActionsTest.java
+++ b/src/test/java/rx/functions/ActionsTest.java
@@ -15,15 +15,14 @@
  */
 package rx.functions;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
-import org.junit.Test;
+import static org.junit.Assert.*;
 
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicLong;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import org.junit.Test;
+
+import rx.TestUtil;
 
 public class ActionsTest {
 
@@ -274,6 +273,6 @@ public void call(Object... args) {
     
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(Actions.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(Actions.class);
     }
 }
diff --git a/src/test/java/rx/functions/FunctionsTest.java b/src/test/java/rx/functions/FunctionsTest.java
index 650713cd8e..819edcda85 100644
--- a/src/test/java/rx/functions/FunctionsTest.java
+++ b/src/test/java/rx/functions/FunctionsTest.java
@@ -15,19 +15,19 @@
  */
 package rx.functions;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
-import org.junit.Test;
+import static org.junit.Assert.assertEquals;
 
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicLong;
 
-import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+import rx.TestUtil;
 
 public class FunctionsTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(Functions.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(Functions.class);
     }
     
     @Test(expected = RuntimeException.class)
diff --git a/src/test/java/rx/internal/operators/BackpressureUtilsTest.java b/src/test/java/rx/internal/operators/BackpressureUtilsTest.java
index e8bc8fe0b7..6501a71792 100644
--- a/src/test/java/rx/internal/operators/BackpressureUtilsTest.java
+++ b/src/test/java/rx/internal/operators/BackpressureUtilsTest.java
@@ -15,15 +15,16 @@
  */
 package rx.internal.operators;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
-import static org.junit.Assert.*;
+
+import rx.TestUtil;
 
 public class BackpressureUtilsTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(BackpressureUtils.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(BackpressureUtils.class);
     }
 
     @Test
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java b/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
index 6b9680f5fd..bd07f55226 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
@@ -15,17 +15,13 @@
  */
 package rx.internal.operators;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
-import java.util.Iterator;
-import java.util.NoSuchElementException;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
 
-import org.junit.Assert;
-
-import org.junit.Test;
+import org.junit.*;
 
 import rx.Observable;
+import rx.TestUtil;
 import rx.observables.BlockingObservable;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
@@ -33,7 +29,7 @@
 public class BlockingOperatorLatestTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(BlockingOperatorLatest.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(BlockingOperatorLatest.class);
     }
 
     @Test(timeout = 1000)
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java b/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java
index 68d545f6c0..4592e96e95 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java
@@ -15,30 +15,24 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 import static rx.internal.operators.BlockingOperatorMostRecent.mostRecent;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import java.util.Iterator;
 import java.util.concurrent.TimeUnit;
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.*;
 
-import rx.Observable;
+import rx.*;
 import rx.exceptions.TestException;
 import rx.observables.BlockingObservable;
 import rx.schedulers.TestScheduler;
-import rx.subjects.PublishSubject;
-import rx.subjects.Subject;
+import rx.subjects.*;
 
 public class BlockingOperatorMostRecentTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(BlockingOperatorMostRecent.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(BlockingOperatorMostRecent.class);
     }
 
     @Test
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
index 8c126a81e1..338c5f5703 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
@@ -15,32 +15,21 @@
  */
 package rx.internal.operators;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+import static org.junit.Assert.*;
+import static rx.internal.operators.BlockingOperatorNext.next;
 
-import org.junit.Assert;
-import org.junit.Test;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
 
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.*;
 
+import rx.*;
 import rx.Observable;
-import rx.Subscriber;
 import rx.exceptions.TestException;
 import rx.observables.BlockingObservable;
 import rx.schedulers.Schedulers;
-import rx.subjects.BehaviorSubject;
-import rx.subjects.PublishSubject;
-import rx.subjects.Subject;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static rx.internal.operators.BlockingOperatorNext.next;
+import rx.subjects.*;
 
 public class BlockingOperatorNextTest {
 
@@ -74,7 +63,7 @@ public void run() {
 
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(BlockingOperatorNext.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(BlockingOperatorNext.class);
     }
 
     @Test
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java b/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
index 998322785f..f4a96834ab 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
@@ -15,31 +15,23 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.Assert.*;
 import static rx.internal.operators.BlockingOperatorToFuture.toFuture;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
-import java.util.List;
-import java.util.NoSuchElementException;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
+import java.util.*;
+import java.util.concurrent.*;
 
 import org.junit.Test;
 
+import rx.*;
 import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.Subscriber;
 import rx.exceptions.TestException;
 
 public class BlockingOperatorToFutureTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(BlockingOperatorToFuture.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(BlockingOperatorToFuture.class);
     }
 
     @Test
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java b/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
index dfad856a62..07a5529a5e 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
@@ -18,15 +18,12 @@
 import static org.junit.Assert.assertEquals;
 import static rx.internal.operators.BlockingOperatorToIterator.toIterator;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import java.util.Iterator;
 
 import org.junit.Test;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Subscriber;
 import rx.exceptions.TestException;
 import rx.internal.operators.BlockingOperatorToIterator.SubscriberIterator;
 import rx.internal.util.RxRingBuffer;
@@ -34,7 +31,7 @@
 public class BlockingOperatorToIteratorTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(BlockingOperatorToIterator.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(BlockingOperatorToIterator.class);
     }
 
     @Test
diff --git a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
index 362867a4a7..8ae5307738 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
@@ -19,21 +19,19 @@
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.*;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 
 import rx.*;
-import rx.observers.*;
+import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 
 public class OnSubscribeToObservableFutureTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(OnSubscribeToObservableFuture.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(OnSubscribeToObservableFuture.class);
     }
 
     @Test
diff --git a/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java b/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java
index 86d7e450fa..cc2eee6fd2 100644
--- a/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java
@@ -16,24 +16,19 @@
 package rx.internal.operators;
 
 import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
+import static org.mockito.Mockito.*;
 
 import org.junit.Test;
 import org.mockito.InOrder;
 
-import rx.Observable;
-import rx.Observer;
+import rx.*;
 import rx.exceptions.TestException;
 import rx.functions.Func2;
 
 public class OperatorSequenceEqualTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(OperatorSequenceEqual.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(OperatorSequenceEqual.class);
     }
 
     @Test
diff --git a/src/test/java/rx/internal/operators/SingleOperatorZipTest.java b/src/test/java/rx/internal/operators/SingleOperatorZipTest.java
index af04971089..56e93071e3 100644
--- a/src/test/java/rx/internal/operators/SingleOperatorZipTest.java
+++ b/src/test/java/rx/internal/operators/SingleOperatorZipTest.java
@@ -15,13 +15,13 @@
  */
 package rx.internal.operators;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import org.junit.Test;
 
+import rx.TestUtil;
+
 public class SingleOperatorZipTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(SingleOperatorZip.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(SingleOperatorZip.class);
     }
 }
diff --git a/src/test/java/rx/internal/util/PlatformDependentTest.java b/src/test/java/rx/internal/util/PlatformDependentTest.java
index 68f653fb64..64f47915b1 100644
--- a/src/test/java/rx/internal/util/PlatformDependentTest.java
+++ b/src/test/java/rx/internal/util/PlatformDependentTest.java
@@ -15,13 +15,13 @@
  */
 package rx.internal.util;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import org.junit.Test;
 
+import rx.TestUtil;
+
 public class PlatformDependentTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(PlatformDependent.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(PlatformDependent.class);
     }
 }
diff --git a/src/test/java/rx/internal/util/UtilityFunctionsTest.java b/src/test/java/rx/internal/util/UtilityFunctionsTest.java
index e610d25634..f30fdf1e98 100644
--- a/src/test/java/rx/internal/util/UtilityFunctionsTest.java
+++ b/src/test/java/rx/internal/util/UtilityFunctionsTest.java
@@ -15,18 +15,13 @@
  */
 package rx.internal.util;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import org.junit.Test;
 
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-
-import static org.junit.Assert.fail;
+import rx.TestUtil;
 
 public class UtilityFunctionsTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(UtilityFunctions.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(UtilityFunctions.class);
     }
 }
diff --git a/src/test/java/rx/internal/util/unsafe/Pow2Test.java b/src/test/java/rx/internal/util/unsafe/Pow2Test.java
index 2b3c9cfaf6..3e8c527726 100644
--- a/src/test/java/rx/internal/util/unsafe/Pow2Test.java
+++ b/src/test/java/rx/internal/util/unsafe/Pow2Test.java
@@ -15,13 +15,13 @@
  */
 package rx.internal.util.unsafe;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import org.junit.Test;
 
+import rx.TestUtil;
+
 public class Pow2Test {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(Pow2.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(Pow2.class);
     }
 }
diff --git a/src/test/java/rx/internal/util/unsafe/UnsafeAccessTest.java b/src/test/java/rx/internal/util/unsafe/UnsafeAccessTest.java
index 1fd5b09c7a..dbcdb44bf5 100644
--- a/src/test/java/rx/internal/util/unsafe/UnsafeAccessTest.java
+++ b/src/test/java/rx/internal/util/unsafe/UnsafeAccessTest.java
@@ -15,13 +15,13 @@
  */
 package rx.internal.util.unsafe;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import org.junit.Test;
 
+import rx.TestUtil;
+
 public class UnsafeAccessTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(UnsafeAccess.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(UnsafeAccess.class);
     }
 }
diff --git a/src/test/java/rx/observers/ObserversTest.java b/src/test/java/rx/observers/ObserversTest.java
index 9f125f1e9a..f769af88d9 100644
--- a/src/test/java/rx/observers/ObserversTest.java
+++ b/src/test/java/rx/observers/ObserversTest.java
@@ -18,24 +18,21 @@
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import java.io.IOException;
-import java.lang.reflect.*;
 import java.util.Queue;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
 import org.junit.*;
 
-import rx.Observer;
+import rx.*;
 import rx.exceptions.*;
 import rx.functions.*;
 
 public class ObserversTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(Observers.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(Observers.class);
     }
     
     @Test
diff --git a/src/test/java/rx/observers/SubscribersTest.java b/src/test/java/rx/observers/SubscribersTest.java
index 76c4a0982e..c98085c612 100644
--- a/src/test/java/rx/observers/SubscribersTest.java
+++ b/src/test/java/rx/observers/SubscribersTest.java
@@ -18,14 +18,11 @@
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
-import java.lang.reflect.*;
 import java.util.concurrent.atomic.*;
 
 import org.junit.Test;
 
-import rx.Subscriber;
+import rx.*;
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.subscriptions.Subscriptions;
@@ -33,7 +30,7 @@
 public class SubscribersTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(Subscribers.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(Subscribers.class);
     }
     
     @Test
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index d4e2b81732..bb737aabe8 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -15,8 +15,6 @@
  */
 package rx.plugins;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import java.lang.reflect.Method;
 
 import org.junit.*;
@@ -40,7 +38,7 @@ public Integer call(Integer t) {
     
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(RxJavaHooks.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(RxJavaHooks.class);
     }
 
     @Test
diff --git a/src/test/java/rx/subscriptions/SubscriptionsTest.java b/src/test/java/rx/subscriptions/SubscriptionsTest.java
index 5186a87438..83f47446a0 100644
--- a/src/test/java/rx/subscriptions/SubscriptionsTest.java
+++ b/src/test/java/rx/subscriptions/SubscriptionsTest.java
@@ -15,24 +15,19 @@
  */
 package rx.subscriptions;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 import static rx.subscriptions.Subscriptions.create;
 
-import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
-
 import org.junit.Test;
 
-import rx.Subscription;
+import rx.*;
 import rx.functions.Action0;
 
 public class SubscriptionsTest {
     @Test
     public void constructorShouldBePrivate() {
-        PrivateConstructorChecker.forClass(Subscriptions.class).expectedTypeOfException(IllegalStateException.class).expectedExceptionMessage("No instances!").check();
+        TestUtil.checkUtilityClass(Subscriptions.class);
     }
 
     @Test

From d66d9313d8580b56a53b28dba32fb1ccacd606b6 Mon Sep 17 00:00:00 2001
From: Artem Zinnatullin <artem.zinnatullin@gmail.com>
Date: Tue, 28 Jun 2016 04:55:19 +0300
Subject: [PATCH 091/263] 1.x: Change Completable.subscribe(onError,
 onComplete) to (onComplete, onError) (#4140)

---
 src/main/java/rx/Completable.java     |  6 +-
 src/test/java/rx/CompletableTest.java | 98 +++++++++++++--------------
 2 files changed, 52 insertions(+), 52 deletions(-)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index c4560cbede..8532bb8e44 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -1933,14 +1933,14 @@ public void onSubscribe(Subscription d) {
     /**
      * Subscribes to this Completable and calls back either the onError or onComplete functions.
      * 
-     * @param onError the consumer that is called if this Completable emits an error
      * @param onComplete the runnable that is called if the Completable completes normally
+     * @param onError the consumer that is called if this Completable emits an error
      * @return the Subscription that can be used for cancelling the subscription asynchronously
      * @throws NullPointerException if either callback is null
      */
-    public final Subscription subscribe(final Action1<? super Throwable> onError, final Action0 onComplete) {
-        requireNonNull(onError);
+    public final Subscription subscribe(final Action0 onComplete, final Action1<? super Throwable> onError) {
         requireNonNull(onComplete);
+        requireNonNull(onError);
         
         final MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
         unsafeSubscribe(new CompletableSubscriber() {
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 0d495cec67..6545cafeef 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -2567,16 +2567,16 @@ public void call() {
     public void subscribeTwoCallbacksNormal() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
         final AtomicBoolean complete = new AtomicBoolean();
-        normal.completable.subscribe(new Action1<Throwable>() {
-            @Override
-            public void call(Throwable e) {
-                err.set(e);
-            }
-        }, new Action0() {
+        normal.completable.subscribe(new Action0() {
             @Override
             public void call() {
                 complete.set(true);
             }
+        }, new Action1<Throwable>() {
+            @Override
+            public void call(Throwable e) {
+                err.set(e);
+            }
         });
         
         Assert.assertNull(err.get());
@@ -2587,16 +2587,16 @@ public void call() {
     public void subscribeTwoCallbacksError() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
         final AtomicBoolean complete = new AtomicBoolean();
-        error.completable.subscribe(new Action1<Throwable>() {
-            @Override
-            public void call(Throwable e) {
-                err.set(e);
-            }
-        }, new Action0() {
+        error.completable.subscribe(new Action0() {
             @Override
             public void call() {
                 complete.set(true);
             }
+        }, new Action1<Throwable>() {
+            @Override
+            public void call(Throwable e) {
+                err.set(e);
+            }
         });
         
         Assert.assertTrue(err.get() instanceof TestException);
@@ -2605,31 +2605,31 @@ public void call() {
     
     @Test(expected = NullPointerException.class)
     public void subscribeTwoCallbacksFirstNull() {
-        normal.completable.subscribe(null, new Action0() {
+        normal.completable.subscribe(null, new Action1<Throwable>() {
             @Override
-            public void call() { }
+            public void call(Throwable throwable) {}
         });
     }
     
     @Test(expected = NullPointerException.class)
     public void subscribeTwoCallbacksSecondNull() {
-        normal.completable.subscribe(null, new Action0() {
+        normal.completable.subscribe(new Action0() {
             @Override
             public void call() { }
-        });
+        }, null);
     }
     
     @Test(timeout = 5000)
     public void subscribeTwoCallbacksCompleteThrows() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
-        normal.completable.subscribe(new Action1<Throwable>() {
+        normal.completable.subscribe(new Action0() {
+            @Override
+            public void call() { throw new TestException(); }
+        }, new Action1<Throwable>() {
             @Override
             public void call(Throwable e) {
                 err.set(e);
             }
-        }, new Action0() {
-            @Override
-            public void call() { throw new TestException(); }
         });
         
         Assert.assertTrue(String.valueOf(err.get()), err.get() instanceof TestException);
@@ -2637,12 +2637,12 @@ public void call(Throwable e) {
     
     @Test(timeout = 5000)
     public void subscribeTwoCallbacksOnErrorThrows() {
-        error.completable.subscribe(new Action1<Throwable>() {
-            @Override
-            public void call(Throwable e) { throw new TestException(); }
-        }, new Action0() {
+        error.completable.subscribe(new Action0() {
             @Override
             public void call() { }
+        }, new Action1<Throwable>() {
+            @Override
+            public void call(Throwable e) { throw new TestException(); }
         });
     }
     
@@ -2800,14 +2800,14 @@ public void subscribeTwoActionsThrowFromOnError() {
         expectUncaughtTestException(new Action0() {
             @Override
             public void call() {
-                error.completable.subscribe(new Action1<Throwable>() {
+                error.completable.subscribe(new Action0() {
                     @Override
-                    public void call(Throwable throwable) {
-                        throw new TestException();
+                    public void call() {
                     }
-                }, new Action0() {
+                }, new Action1<Throwable>() {
                     @Override
-                    public void call() {
+                    public void call(Throwable throwable) {
+                        throw new TestException();
                     }
                 });
             }
@@ -3132,14 +3132,14 @@ public void ambArrayOneFiresError() {
         
         final AtomicReference<Throwable> complete = new AtomicReference<Throwable>();
         
-        c.subscribe(new Action1<Throwable>() {
+        c.subscribe(new Action0() {
+            @Override
+            public void call() { }
+        }, new Action1<Throwable>() {
             @Override
             public void call(Throwable e) {
                 complete.set(e);
             }
-        }, new Action0() {
-            @Override
-            public void call() { }
         });
         
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
@@ -3197,14 +3197,14 @@ public void ambArraySecondFiresError() {
         
         final AtomicReference<Throwable> complete = new AtomicReference<Throwable>();
         
-        c.subscribe(new Action1<Throwable>() {
+        c.subscribe(new Action0() {
+            @Override
+            public void call() { }
+        }, new Action1<Throwable>() {
             @Override
             public void call(Throwable e) {
                 complete.set(e);
             }
-        }, new Action0() {
-            @Override
-            public void call() { }
         });
         
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
@@ -3363,14 +3363,14 @@ public void ambWithArrayOneFiresError() {
         
         final AtomicReference<Throwable> complete = new AtomicReference<Throwable>();
         
-        c.subscribe(new Action1<Throwable>() {
+        c.subscribe(new Action0() {
+            @Override
+            public void call() { }
+        }, new Action1<Throwable>() {
             @Override
             public void call(Throwable e) {
                 complete.set(e);
             }
-        }, new Action0() {
-            @Override
-            public void call() { }
         });
         
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
@@ -3428,14 +3428,14 @@ public void ambWithArraySecondFiresError() {
         
         final AtomicReference<Throwable> complete = new AtomicReference<Throwable>();
         
-        c.subscribe(new Action1<Throwable>() {
+        c.subscribe(new Action0() {
+            @Override
+            public void call() { }
+        }, new Action1<Throwable>() {
             @Override
             public void call(Throwable e) {
                 complete.set(e);
             }
-        }, new Action0() {
-            @Override
-            public void call() { }
         });
         
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
@@ -3841,14 +3841,14 @@ public void subscribeAction2ReportsUnsubscribedAfter() {
         Completable completable = stringSubject.toCompletable();
         
         final AtomicReference<Subscription> subscriptionRef = new AtomicReference<Subscription>();
-        Subscription completableSubscription = completable.subscribe(Actions.empty(), new Action0() {
+        Subscription completableSubscription = completable.subscribe(new Action0() {
             @Override
             public void call() {
                 if (subscriptionRef.get().isUnsubscribed()) {
                     subscriptionRef.set(null);
                 }
             }
-        });
+        }, Actions.empty());
         subscriptionRef.set(completableSubscription);
         
         stringSubject.onCompleted();
@@ -3863,14 +3863,14 @@ public void subscribeAction2ReportsUnsubscribedOnErrorAfter() {
         Completable completable = stringSubject.toCompletable();
         
         final AtomicReference<Subscription> subscriptionRef = new AtomicReference<Subscription>();
-        Subscription completableSubscription = completable.subscribe(new Action1<Throwable>() {
+        Subscription completableSubscription = completable.subscribe(Actions.empty(), new Action1<Throwable>() {
             @Override
             public void call(Throwable e) {
                 if (subscriptionRef.get().isUnsubscribed()) {
                     subscriptionRef.set(null);
                 }
             }
-        }, Actions.empty());
+        });
         subscriptionRef.set(completableSubscription);
         
         stringSubject.onError(new TestException());

From ee63affc1c237ecabccbdc2a7d9398e3d5c39372 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 29 Jun 2016 14:47:28 +0200
Subject: [PATCH 092/263] 1.x: add RxJavaHooks tests, fix small bugs (#4142)

* 1.x: add RxJavaHooks tests, fix small bugs

* Add onSchedule hook test

* Use static assert, update Conpletable param name
---
 src/main/java/rx/Completable.java             |  33 +-
 src/main/java/rx/plugins/RxJavaHooks.java     |   6 +-
 src/main/java/rx/schedulers/Schedulers.java   |   2 +-
 src/test/java/rx/plugins/RxJavaHooksTest.java | 407 +++++++++++++++++-
 4 files changed, 428 insertions(+), 20 deletions(-)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 8532bb8e44..c32a0a2ea8 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -87,21 +87,21 @@ public interface CompletableTransformer extends Func1<Completable, Completable>
     }
     
     /** Single instance of a complete Completable. */
-    static final Completable COMPLETE = create(new CompletableOnSubscribe() {
+    static final Completable COMPLETE = new Completable(new CompletableOnSubscribe() {
         @Override
         public void call(CompletableSubscriber s) {
             s.onSubscribe(Subscriptions.unsubscribed());
             s.onCompleted();
         }
-    });
+    }, true); // hook is handled in complete()
     
     /** Single instance of a never Completable. */
-    static final Completable NEVER = create(new CompletableOnSubscribe() {
+    static final Completable NEVER = new Completable(new CompletableOnSubscribe() {
         @Override
         public void call(CompletableSubscriber s) {
             s.onSubscribe(Subscriptions.unsubscribed());
         }
-    });
+    }, true); // hook is handled in never()
     
     /**
      * Returns a Completable which terminates as soon as one of the source Completables
@@ -311,7 +311,11 @@ public void onSubscribe(Subscription d) {
      * @return a Completable instance that completes immediately 
      */
     public static Completable complete() {
-        return COMPLETE;
+        CompletableOnSubscribe cos = RxJavaHooks.onCreate(COMPLETE.onSubscribe);
+        if (cos == COMPLETE.onSubscribe) {
+            return COMPLETE;
+        }
+        return new Completable(cos, true);
     }
     
     /**
@@ -734,7 +738,11 @@ public static Completable mergeDelayError(Observable<? extends Completable> sour
      * @return the singleton instance that never calls onError or onComplete
      */
     public static Completable never() {
-        return NEVER;
+        CompletableOnSubscribe cos = RxJavaHooks.onCreate(NEVER.onSubscribe);
+        if (cos == NEVER.onSubscribe) {
+            return NEVER;
+        }
+        return new Completable(cos, true);
     }
     
     /**
@@ -975,7 +983,18 @@ public void call() {
     protected Completable(CompletableOnSubscribe onSubscribe) {
         this.onSubscribe = RxJavaHooks.onCreate(onSubscribe);
     }
-    
+
+    /**
+     * Constructs a Completable instance with the given onSubscribe callback without calling the onCreate
+     * hook.
+     * @param onSubscribe the callback that will receive CompletableSubscribers when they subscribe,
+     * not null (not verified)
+     * @param useHook if false, RxJavaHooks.onCreate won't be called
+     */
+    private Completable(CompletableOnSubscribe onSubscribe, boolean useHook) {
+        this.onSubscribe = useHook ? RxJavaHooks.onCreate(onSubscribe) : onSubscribe;
+    }
+
     /**
      * Returns a Completable that emits the a terminated event of either this Completable
      * or the other Completable whichever fires first.
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index 0adb0af9e9..1307c78417 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -171,6 +171,10 @@ public static void reset() {
             return;
         }
         init();
+        
+        onComputationScheduler = null;
+        onIOScheduler = null;
+        onNewThreadScheduler = null;
     }
 
     /**
@@ -224,7 +228,7 @@ public static void onError(Throwable ex) {
         Action1<Throwable> f = onError;
         if (f != null) {
             try {
-            f.call(ex);
+                f.call(ex);
                 return;
             } catch (Throwable pluginException) {
                 /*
diff --git a/src/main/java/rx/schedulers/Schedulers.java b/src/main/java/rx/schedulers/Schedulers.java
index 5155dfb297..a24504f94d 100644
--- a/src/main/java/rx/schedulers/Schedulers.java
+++ b/src/main/java/rx/schedulers/Schedulers.java
@@ -137,7 +137,7 @@ public static Scheduler computation() {
      * @return a {@link Scheduler} meant for IO-bound work
      */
     public static Scheduler io() {
-        return RxJavaHooks.onComputationScheduler(getInstance().ioScheduler);
+        return RxJavaHooks.onIOScheduler(getInstance().ioScheduler);
     }
 
     /**
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index bb737aabe8..56599cf874 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -16,14 +16,25 @@
 package rx.plugins;
 
 import java.lang.reflect.Method;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicInteger;
 
-import org.junit.*;
+import org.junit.Test;
 
 import rx.*;
+import rx.Completable.*;
+import rx.Observable.OnSubscribe;
+import rx.Scheduler.Worker;
 import rx.exceptions.*;
 import rx.functions.*;
+import rx.internal.operators.OnSubscribeRange;
+import rx.internal.producers.SingleProducer;
 import rx.internal.util.UtilityFunctions;
 import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
+import rx.subscriptions.Subscriptions;
+import static org.junit.Assert.*;
+
 
 public class RxJavaHooksTest {
 
@@ -53,11 +64,11 @@ public void assemblyTrackingObservable() {
             
             Throwable ex = ts.getOnErrorEvents().get(0);
             
-            Assert.assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
+            assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
             
-            Assert.assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
+            assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
             
-            Assert.assertTrue(ex.getMessage(), ex.getMessage().contains("createObservable"));
+            assertTrue(ex.getMessage(), ex.getMessage().contains("createObservable"));
         } finally {
             RxJavaHooks.resetAssemblyTracking();
         }
@@ -84,11 +95,11 @@ public void assemblyTrackingSingle() {
             
             Throwable ex = ts.getOnErrorEvents().get(0);
 
-            Assert.assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
+            assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
 
-            Assert.assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
+            assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
 
-            Assert.assertTrue(ex.getMessage(), ex.getMessage().contains("createSingle"));
+            assertTrue(ex.getMessage(), ex.getMessage().contains("createSingle"));
         } finally {
             RxJavaHooks.resetAssemblyTracking();
         }
@@ -115,11 +126,11 @@ public void assemblyTrackingCompletable() {
             
             Throwable ex = ts.getOnErrorEvents().get(0);
 
-            Assert.assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
+            assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
 
-            Assert.assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
+            assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
 
-            Assert.assertTrue(ex.getMessage(), ex.getMessage().contains("createCompletable"));
+            assertTrue(ex.getMessage(), ex.getMessage().contains("createCompletable"));
         } finally {
             RxJavaHooks.resetAssemblyTracking();
         }
@@ -158,7 +169,7 @@ public Object call(Object t1, Object t2) {
                     
                     Object after = getter.invoke(null);
                     
-                    Assert.assertSame(m.toString(), before, after);
+                    assertSame(m.toString(), before, after);
                 }
             }
             
@@ -167,4 +178,378 @@ public Object call(Object t1, Object t2) {
             RxJavaHooks.reset();
         }
     }
+    
+    Func1<Scheduler, Scheduler> replaceWithImmediate = new Func1<Scheduler, Scheduler>() {
+        @Override
+        public Scheduler call(Scheduler t) {
+            return Schedulers.immediate();
+        }
+    };
+    
+    @Test
+    public void overrideComputationScheduler() {
+        try {
+            RxJavaHooks.setOnComputationScheduler(replaceWithImmediate);
+            
+            assertSame(Schedulers.immediate(), Schedulers.computation());
+        } finally {
+            RxJavaHooks.reset();
+        }
+        // make sure the reset worked
+        assertNotSame(Schedulers.immediate(), Schedulers.computation());
+    }
+
+    @Test
+    public void overrideIoScheduler() {
+        try {
+            RxJavaHooks.setOnIOScheduler(replaceWithImmediate);
+            
+            assertSame(Schedulers.immediate(), Schedulers.io());
+        } finally {
+            RxJavaHooks.reset();
+        }
+        // make sure the reset worked
+        assertNotSame(Schedulers.immediate(), Schedulers.io());
+    }
+
+    @Test
+    public void overrideNewThreadScheduler() {
+        try {
+            RxJavaHooks.setOnNewThreadScheduler(replaceWithImmediate);
+            
+            assertSame(Schedulers.immediate(), Schedulers.newThread());
+        } finally {
+            RxJavaHooks.reset();
+        }
+        // make sure the reset worked
+        assertNotSame(Schedulers.immediate(), Schedulers.newThread());
+    }
+
+    @SuppressWarnings("rawtypes")
+    @Test
+    public void observableCreate() {
+        try {
+            RxJavaHooks.setOnObservableCreate(new Func1<OnSubscribe, OnSubscribe>() {
+                @Override
+                public OnSubscribe call(OnSubscribe t) {
+                    return new OnSubscribeRange(1, 2);
+                }
+            });
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            Observable.range(10, 3).subscribe(ts);
+            
+            ts.assertValues(1, 2);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+        // make sure the reset worked
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(10, 3).subscribe(ts);
+        
+        ts.assertValues(10, 11, 12);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings("rawtypes")
+    @Test
+    public void observableStart() {
+        try {
+            RxJavaHooks.setOnObservableStart(new Func2<Observable, OnSubscribe, OnSubscribe>() {
+                @Override
+                public OnSubscribe call(Observable o, OnSubscribe t) {
+                    return new OnSubscribeRange(1, 2);
+                }
+            });
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            Observable.range(10, 3).subscribe(ts);
+            
+            ts.assertValues(1, 2);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+        // make sure the reset worked
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(10, 3).subscribe(ts);
+        
+        ts.assertValues(10, 11, 12);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void observableReturn() {
+        try {
+            final Subscription s = Subscriptions.empty();
+            
+            RxJavaHooks.setOnObservableReturn(new Func1<Subscription, Subscription>() {
+                @Override
+                public Subscription call(Subscription t) {
+                    return s;
+                }
+            });
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            Subscription u = Observable.range(10, 3).subscribe(ts);
+            
+            ts.assertValues(10, 11, 12);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+            
+            assertSame(s, u);
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+
+    @SuppressWarnings("rawtypes")
+    @Test
+    public void singleCreate() {
+        try {
+            RxJavaHooks.setOnSingleCreate(new Func1<Single.OnSubscribe, Single.OnSubscribe>() {
+                @Override
+                public Single.OnSubscribe call(Single.OnSubscribe t) {
+                    return new Single.OnSubscribe<Object>() {
+                        @Override
+                        public void call(SingleSubscriber<Object> t) {
+                            t.onSuccess(10);
+                        }
+                    };
+                }
+            });
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            Single.just(1).subscribe(ts);
+            
+            ts.assertValue(10);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+        // make sure the reset worked
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Single.just(1).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings("rawtypes")
+    @Test
+    public void singleStart() {
+        try {
+            RxJavaHooks.setOnSingleStart(new Func2<Single, OnSubscribe, OnSubscribe>() {
+                @Override
+                public OnSubscribe call(Single o, OnSubscribe t) {
+                    return new OnSubscribe<Object>() {
+                        @Override
+                        public void call(Subscriber<Object> t) {
+                            t.setProducer(new SingleProducer<Integer>(t, 10));
+                        }
+                    };
+                }
+            });
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            Single.just(1).subscribe(ts);
+            
+            ts.assertValue(10);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+        // make sure the reset worked
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Single.just(1).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void singleReturn() {
+        try {
+            final Subscription s = Subscriptions.empty();
+            
+            RxJavaHooks.setOnSingleReturn(new Func1<Subscription, Subscription>() {
+                @Override
+                public Subscription call(Subscription t) {
+                    return s;
+                }
+            });
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            Subscription u = Single.just(1).subscribe(ts);
+            
+            ts.assertValue(1);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+            
+            assertSame(s, u);
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+
+    @Test
+    public void completableCreate() {
+        try {
+            RxJavaHooks.setOnCompletableCreate(new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
+                @Override
+                public CompletableOnSubscribe call(CompletableOnSubscribe t) {
+                    return new CompletableOnSubscribe() {
+                        @Override
+                        public void call(CompletableSubscriber t) {
+                            t.onError(new TestException());
+                        }
+                    };
+                }
+            });
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            Completable.complete().subscribe(ts);
+            
+            ts.assertNoValues();
+            ts.assertNotCompleted();
+            ts.assertError(TestException.class);
+        } finally {
+            RxJavaHooks.reset();
+        }
+        // make sure the reset worked
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Completable.complete().subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void completableStart() {
+        try {
+            RxJavaHooks.setOnCompletableStart(new Func2<Completable, CompletableOnSubscribe, CompletableOnSubscribe>() {
+                @Override
+                public CompletableOnSubscribe call(Completable o, CompletableOnSubscribe t) {
+                    return new CompletableOnSubscribe() {
+                        @Override
+                        public void call(CompletableSubscriber t) {
+                            t.onError(new TestException());
+                        }
+                    };
+                }
+            });
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            Completable.complete().subscribe(ts);
+            
+            ts.assertNoValues();
+            ts.assertNotCompleted();
+            ts.assertError(TestException.class);
+        } finally {
+            RxJavaHooks.reset();
+        }
+        // make sure the reset worked
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Completable.complete().subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    void onSchedule(Worker w) throws InterruptedException {
+        try {
+            try {
+                final AtomicInteger value = new AtomicInteger();
+                final CountDownLatch cdl = new CountDownLatch(1);
+                
+                RxJavaHooks.setOnScheduleAction(new Func1<Action0, Action0>() {
+                    @Override
+                    public Action0 call(Action0 t) {
+                        return new Action0() {
+                            @Override
+                            public void call() {
+                                value.set(10);
+                                cdl.countDown();
+                            }
+                        };
+                    }
+                });
+                
+                w.schedule(new Action0() {
+                    @Override
+                    public void call() {
+                        value.set(1);
+                        cdl.countDown();
+                    }
+                });
+                
+                cdl.await();
+                
+                assertEquals(10, value.get());
+                
+            } finally {
+                
+                RxJavaHooks.reset();
+            }
+            
+            // make sure the reset worked
+            final AtomicInteger value = new AtomicInteger();
+            final CountDownLatch cdl = new CountDownLatch(1);
+            
+            w.schedule(new Action0() {
+                @Override
+                public void call() {
+                    value.set(1);
+                    cdl.countDown();
+                }
+            });
+            
+            cdl.await();
+            
+            assertEquals(1, value.get());
+        } finally {
+            w.unsubscribe();
+        }
+    }
+    
+    @Test
+    public void onScheduleComputation() throws InterruptedException {
+        onSchedule(Schedulers.computation().createWorker());
+    }
+
+    @Test
+    public void onScheduleIO() throws InterruptedException {
+        onSchedule(Schedulers.io().createWorker());
+    }
+
+    @Test
+    public void onScheduleNewThread() throws InterruptedException {
+        onSchedule(Schedulers.newThread().createWorker());
+    }
+
 }

From cec891510bb4cdb379d11691eaf004289a50d044 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 29 Jun 2016 15:49:09 +0200
Subject: [PATCH 093/263] Fix the initialization of Completable.complete()
 (#4146)

---
 src/main/java/rx/Completable.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index c32a0a2ea8..2f6f3cce50 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -93,7 +93,7 @@ public void call(CompletableSubscriber s) {
             s.onSubscribe(Subscriptions.unsubscribed());
             s.onCompleted();
         }
-    }, true); // hook is handled in complete()
+    }, false); // hook is handled in complete()
     
     /** Single instance of a never Completable. */
     static final Completable NEVER = new Completable(new CompletableOnSubscribe() {
@@ -101,7 +101,7 @@ public void call(CompletableSubscriber s) {
         public void call(CompletableSubscriber s) {
             s.onSubscribe(Subscriptions.unsubscribed());
         }
-    }, true); // hook is handled in never()
+    }, false); // hook is handled in never()
     
     /**
      * Returns a Completable which terminates as soon as one of the source Completables
@@ -315,7 +315,7 @@ public static Completable complete() {
         if (cos == COMPLETE.onSubscribe) {
             return COMPLETE;
         }
-        return new Completable(cos, true);
+        return new Completable(cos, false);
     }
     
     /**
@@ -742,7 +742,7 @@ public static Completable never() {
         if (cos == NEVER.onSubscribe) {
             return NEVER;
         }
-        return new Completable(cos, true);
+        return new Completable(cos, false);
     }
     
     /**

From 27297a42ba21432edd7a161603a4d4e6383faf78 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 7 Jul 2016 20:58:17 +0200
Subject: [PATCH 094/263] 1.x: benchmark reduce and takeLast(1) (#4174)

* 1.x: benchmark reduce and takeLast(1)

* add collect() benchmark
---
 src/perf/java/rx/DeferredScalarPerf.java | 106 +++++++++++++++++++++++
 1 file changed, 106 insertions(+)
 create mode 100644 src/perf/java/rx/DeferredScalarPerf.java

diff --git a/src/perf/java/rx/DeferredScalarPerf.java b/src/perf/java/rx/DeferredScalarPerf.java
new file mode 100644
index 0000000000..fb96df3bdf
--- /dev/null
+++ b/src/perf/java/rx/DeferredScalarPerf.java
@@ -0,0 +1,106 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx;
+
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+
+import rx.functions.*;
+import rx.jmh.LatchedObserver;
+
+/**
+ * Benchmark operators that consume their sources completely and signal a single value.
+ * <p>
+ * gradlew benchmarks "-Pjmh=-f 1 -tu s -bm thrpt -wi 5 -i 5 -r 1 .*DeferredScalarPerf.*"
+ * <p>
+ * gradlew benchmarks "-Pjmh=-f 1 -tu ns -bm avgt -wi 5 -i 5 -r 1 .*DeferredScalarPerf.*"
+ */
+@BenchmarkMode(Mode.Throughput)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@State(Scope.Thread)
+public class DeferredScalarPerf {
+
+    @Param({"1", "10", "100", "1000", "10000", "100000", "1000000"})
+    public int count;
+
+    Observable<Integer> last;
+
+    Observable<Integer> reduce;
+
+    Observable<Integer> reduceSeed;
+    
+    Observable<int[]> collect;
+
+    @Setup
+    public void setup() {
+        Integer[] array = new Integer[count];
+        Arrays.fill(array, 777);
+        
+        Observable<Integer> source = Observable.from(array);
+        
+        reduce = source.reduce(new Func2<Integer, Integer, Integer>() {
+            @Override
+            public Integer call(Integer a, Integer b) {
+                return b;
+            }
+        });
+        reduceSeed = source.reduce(0, new Func2<Integer, Integer, Integer>() {
+            @Override
+            public Integer call(Integer a, Integer b) {
+                return b;
+            }
+        });
+        
+        last = source.takeLast(1);
+        
+        collect = source.collect(new Func0<int[]>() {
+            @Override
+            public int[] call() {
+                return new int[1];
+            }
+        }, new Action2<int[], Integer>() {
+            @Override
+            public void call(int[] a, Integer b) { 
+                a[0] = b.intValue(); 
+            }
+        } );
+    }
+    
+//    @Benchmark
+    public void reduce(Blackhole bh) {
+        reduce.subscribe(new LatchedObserver<Integer>(bh));
+    }
+
+//    @Benchmark
+    public void reduceSeed(Blackhole bh) {
+        reduceSeed.subscribe(new LatchedObserver<Integer>(bh));
+    }
+
+//    @Benchmark
+    public void last(Blackhole bh) {
+        last.subscribe(new LatchedObserver<Integer>(bh));
+    }
+
+    @Benchmark
+    public void collect(Blackhole bh) {
+        collect.subscribe(new LatchedObserver<int[]>(bh));
+    }
+
+}

From 20ef8579a0d7c9bafb7bc4dcd127ddb0476df883 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 7 Jul 2016 22:09:38 +0200
Subject: [PATCH 095/263] 1.x: add missing backpressure descriptions and update
 old ones (#4172)

* 1.x: add missing backpressure descriptions and update old ones

* Update based on suggestions
---
 src/main/java/rx/Observable.java | 1187 ++++++++++++++++++++++++++----
 1 file changed, 1051 insertions(+), 136 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index a63a2594ed..a949467c6d 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -60,6 +60,8 @@ protected Observable(OnSubscribe<T> f) {
     }
 
     /**
+     * <strong>This method requires advanced knowledge about building operators and data sources; please consider
+     * other standard methods first;</strong> 
      * Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to
      * it.
      * <p>
@@ -75,6 +77,10 @@ protected Observable(OnSubscribe<T> f) {
      * See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed
      * information.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The {@code OnSubscribe} instance provided is responsible to be backpressure-aware or
+     *  document the fact that the consumer of the returned {@code Observable} has to apply one of
+     *  the {@code onBackpressureXXX} operators.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -108,6 +114,8 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
      * See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed
      * information.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure and generates values on-demand (when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -149,6 +157,8 @@ public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe)
      * See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed
      * information.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure and generates values on-demand (when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -198,7 +208,7 @@ public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<
      * (enabling chaining). 
      * 
      * @param <R> the output type of the conversion function
-     * @param conversion a function that converts from this {@code Observable<T>} to an {@code R}
+     * @param conversion a function that converts from the source {@code Observable<T>} to an {@code R}
      * @return an instance of R created by the provided conversion function
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
@@ -224,6 +234,8 @@ public void call(Subscriber<? super T> subscriber) {
     }
     
     /**
+     * <strong>This method requires advanced knowledge about building operators; please consider
+     * other standard composition methods first;</strong>
      * Lifts a function to the current Observable and returns a new Observable that when subscribed to will pass
      * the values of the current Observable through the Operator function.
      * <p>
@@ -237,6 +249,10 @@ public void call(Subscriber<? super T> subscriber) {
      * Observable, use {@code lift}. If your operator is designed to transform the source Observable as a whole
      * (for instance, by applying a particular set of existing RxJava operators to it) use {@link #compose}.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The {@code Operator} instance provided is responsible to be backpressure-aware or
+     *  document the fact that the consumer of the returned {@code Observable} has to apply one of
+     *  the {@code onBackpressureXXX} operators.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code lift} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -261,6 +277,9 @@ public final <R> Observable<R> lift(final Operator<? extends R, ? super T> opera
      * Observable, use {@link #lift}. If your operator is designed to transform the source Observable as a whole
      * (for instance, by applying a particular set of existing RxJava operators to it) use {@code compose}.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with the backpressure behavior which only depends
+     *  on what kind of {@code Observable} the transformer returns.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code compose} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -297,6 +316,9 @@ public interface Transformer<T, R> extends Func1<Observable<T>, Observable<R>> {
      * <p>
      * <img width="640" height="295" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Single.toSingle.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator ignores backpressure on the source {@code Observable} and the returned {@code Single} 
+     *  does not have a notion of backpressure.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toSingle} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -323,6 +345,9 @@ public Single<T> toSingle() {
      * "https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Completable.toCompletable.png"
      * alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator ignores backpressure on the source {@code Observable} and the returned {@code Completable} 
+     *  does not have a notion of backpressure.</dd>
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code toCompletable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -351,6 +376,9 @@ public Completable toCompletable() {
      * <p>
      * <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by the winning
+     *  {@code Observable}'s backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -372,6 +400,9 @@ public static <T> Observable<T> amb(Iterable<? extends Observable<? extends T>>
      * <p>
      * <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by the winning
+     *  {@code Observable}'s backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -395,6 +426,9 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * <p>
      * <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by the winning
+     *  {@code Observable}'s backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -420,6 +454,9 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * <p>
      * <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by the winning
+     *  {@code Observable}'s backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -447,6 +484,9 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * <p>
      * <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by the winning
+     *  {@code Observable}'s backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -476,6 +516,9 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * <p>
      * <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by the winning
+     *  {@code Observable}'s backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -507,6 +550,9 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * <p>
      * <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by the winning
+     *  {@code Observable}'s backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -540,6 +586,9 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * <p>
      * <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by the winning
+     *  {@code Observable}'s backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -575,6 +624,9 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * <p>
      * <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by the winning
+     *  {@code Observable}'s backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -613,6 +665,10 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
+     *   are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal
+     *   {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -642,6 +698,10 @@ public static <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
+     *   are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal
+     *   {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -674,6 +734,10 @@ public static <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
+     *   are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal
+     *   {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -710,6 +774,10 @@ public static <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? exten
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
+     *   are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal
+     *   {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -749,6 +817,10 @@ public static <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? e
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
+     *   are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal
+     *   {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -791,6 +863,10 @@ public static <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
+     *   are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal
+     *   {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -836,6 +912,10 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observ
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
+     *   are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal
+     *   {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -884,6 +964,10 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Ob
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/combineLatest.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
+     *   are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal
+     *   {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -933,6 +1017,10 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combineLates
      * the source Observables each time an item is received from any of the source Observables, where this
      * aggregation is defined by a specified function.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
+     *   are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal
+     *   {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -958,6 +1046,10 @@ public static <T, R> Observable<R> combineLatest(List<? extends Observable<? ext
      * the source Observables each time an item is received from any of the source Observables, where this
      * aggregation is defined by a specified function.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
+     *   are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal
+     *   {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -985,6 +1077,10 @@ public static <T, R> Observable<R> combineLatest(Iterable<? extends Observable<?
      * all source Observables terminate.
      * 
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
+     *   are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal
+     *   {@code MissingBackpressureException}) and may lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1011,6 +1107,11 @@ public static <T, R> Observable<R> combineLatestDelayError(Iterable<? extends Ob
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. Both the outer and inner {@code Observable}
+     *  sources are expected to honor backpressure as well. If the outer violates this, a 
+     *  {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates
+     *  this, it <em>may</em> throw an {@code IllegalStateException} when an inner {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1033,6 +1134,11 @@ public static <T> Observable<T> concat(Observable<? extends Observable<? extends
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1056,6 +1162,11 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1081,6 +1192,11 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1108,6 +1224,11 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1137,6 +1258,11 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1168,6 +1294,11 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1201,6 +1332,11 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1236,6 +1372,11 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1294,7 +1435,10 @@ public static <T> Observable<T> concatDelayError(Observable<? extends Observable
      * 
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>{@code concatDelayError} fully supports backpressure.</dd>
+     *  <dd>The operator honors backpressure from downstream. Both the outer and inner {@code Observable}
+     *  sources are expected to honor backpressure as well. If the outer violates this, a 
+     *  {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates
+     *  this, it <em>may</em> throw an {@code IllegalStateException} when an inner {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1319,6 +1463,9 @@ public static <T> Observable<T> concatDelayError(Iterable<? extends Observable<?
      * Observer subscribes to the Observable. This allows an {@link Observer} to easily obtain updates or a
      * refreshed version of the sequence.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by the {@code Observable}
+     *  returned by the {@code observableFactory}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code defer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1342,6 +1489,8 @@ public static <T> Observable<T> defer(Func0<Observable<T>> observableFactory) {
      * <p>
      * <img width="640" height="190" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/empty.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This source doesn't produce any elements and effectively ignores downstream backpressure.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code empty} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1362,6 +1511,8 @@ public static <T> Observable<T> empty() {
      * <p>
      * <img width="640" height="190" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/error.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This source doesn't produce any elements and effectively ignores downstream backpressure.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code error} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1389,6 +1540,8 @@ public static <T> Observable<T> error(Throwable exception) {
      * <p>
      * <em>Important note:</em> This Observable is blocking; you cannot unsubscribe from it.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code from} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1417,6 +1570,8 @@ public static <T> Observable<T> from(Future<? extends T> future) {
      * <p>
      * <em>Important note:</em> This Observable is blocking; you cannot unsubscribe from it.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code from} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1447,6 +1602,8 @@ public static <T> Observable<T> from(Future<? extends T> future, long timeout, T
      * return value of the {@link Future#get} method of that object, by passing the object into the {@code from}
      * method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -1474,6 +1631,9 @@ public static <T> Observable<T> from(Future<? extends T> future, Scheduler sched
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/from.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and iterates the given {@code iterable}
+     *  on demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code from} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1495,6 +1655,9 @@ public static <T> Observable<T> from(Iterable<? extends T> iterable) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/from.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and iterates the given {@code array}
+     *  on demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code from} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1526,6 +1689,8 @@ public static <T> Observable<T> from(T[] array) {
      * This allows you to defer the execution of the function you specify until an observer subscribes to the
      * Observable. That is to say, it makes the function "lazy."
      * <dl>
+     *   <dt><b>Backpressure:</b></dt>
+     *   <dd>The operator honors backpressure from downstream.</dd>
      *   <dt><b>Scheduler:</b></dt>
      *   <dd>{@code fromCallable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1570,6 +1735,10 @@ public static Observable<Long> interval(long interval, TimeUnit unit) {
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/interval.s.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator generates values based on time and ignores downstream backpressure which
+     *  may lead to {@code MissingBackpressureException} at some point in the chain.
+     *  Consumers should consider applying one of the {@code onBackpressureXXX} operators as well.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -1593,9 +1762,10 @@ public static Observable<Long> interval(long interval, TimeUnit unit, Scheduler
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timer.p.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses time. If the downstream needs a slower rate
-     *      it should slow the timer or use something like {@link #onBackpressureDrop}.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator generates values based on time and ignores downstream backpressure which
+     *  may lead to {@code MissingBackpressureException} at some point in the chain.
+     *  Consumers should consider applying one of the {@code onBackpressureXXX} operators as well.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code interval} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -1621,9 +1791,10 @@ public static Observable<Long> interval(long initialDelay, long period, TimeUnit
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timer.ps.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses time. If the downstream needs a slower rate
-     *      it should slow the timer or use something like {@link #onBackpressureDrop}.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator generates values based on time and ignores downstream backpressure which
+     *  may lead to {@code MissingBackpressureException} at some point in the chain.
+     *  Consumers should consider applying one of the {@code onBackpressureXXX} operators as well.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -1658,6 +1829,8 @@ public static Observable<Long> interval(long initialDelay, long period, TimeUnit
      * time, while the {@code just} method converts an Iterable into an Observable that emits the entire
      * Iterable as a single item.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1678,6 +1851,8 @@ public static <T> Observable<T> just(final T value) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/just.m.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1702,6 +1877,8 @@ public static <T> Observable<T> just(T t1, T t2) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/just.m.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1728,6 +1905,8 @@ public static <T> Observable<T> just(T t1, T t2, T t3) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/just.m.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1756,6 +1935,8 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/just.m.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1786,6 +1967,8 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/just.m.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1818,6 +2001,8 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/just.m.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1852,6 +2037,8 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/just.m.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1888,6 +2075,8 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/just.m.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1926,6 +2115,8 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/just.m.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1969,6 +2160,9 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      * You can combine the items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -1993,6 +2187,9 @@ public static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>
      * You can combine the items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2021,6 +2218,10 @@ public static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>
      * You can combine the items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The outer {@code Observable} is consumed
+     *  in unbounded mode (i.e., no backpressure is applied to it). The inner {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2050,6 +2251,9 @@ public static <T> Observable<T> merge(Observable<? extends Observable<? extends
      * You can combine the items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. Both the outer and inner {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2082,6 +2286,9 @@ public static <T> Observable<T> merge(Observable<? extends Observable<? extends
      * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2107,6 +2314,9 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2134,6 +2344,9 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2163,6 +2376,9 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2194,6 +2410,9 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2227,6 +2446,9 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2262,6 +2484,9 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2299,6 +2524,9 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2338,6 +2566,9 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2361,6 +2592,9 @@ public static <T> Observable<T> merge(Observable<? extends T>[] sequences) {
      * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code merge} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2392,6 +2626,10 @@ public static <T> Observable<T> merge(Observable<? extends T>[] sequences, int m
      * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
      * invoke the {@code onError} method of its Observers once.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The outer {@code Observable} is consumed
+     *  in unbounded mode (i.e., no backpressure is applied to it). The inner {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2422,6 +2660,9 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends Observable<
      * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
      * invoke the {@code onError} method of its Observers once.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. Both the outer and inner {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2516,6 +2757,9 @@ public static <T> Observable<T> mergeDelayError(Iterable<? extends Observable<?
      * Even if both merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
      * invoke the {@code onError} method of its Observers once.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2547,6 +2791,9 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
      * invoke the {@code onError} method of its Observers once.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2580,6 +2827,9 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
      * invoke the {@code onError} method of its Observers once.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2615,6 +2865,9 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
      * invoke the {@code onError} method of its Observers once.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2652,6 +2905,9 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
      * invoke the {@code onError} method of its Observers once.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2692,6 +2948,9 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
      * invoke the {@code onError} method of its Observers once.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2733,6 +2992,9 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
      * invoke the {@code onError} method of its Observers once.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2776,6 +3038,9 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      * Even if multiple merged Observables send {@code onError} notifications, {@code mergeDelayError} will only
      * invoke the {@code onError} method of its Observers once.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2812,6 +3077,8 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      * <p>
      * <img width="640" height="350" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/nest.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code nest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2830,6 +3097,8 @@ public final Observable<Observable<T>> nest() {
      * <p>
      * This Observable is useful primarily for testing purposes.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This source doesn't produce any elements and effectively ignores downstream backpressure.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code never} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2848,6 +3117,8 @@ public static <T> Observable<T> never() {
      * <p>
      * <img width="640" height="195" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/range.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and signals values on-demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code range} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2884,6 +3155,8 @@ public static Observable<Integer> range(int start, int count) {
      * <p>
      * <img width="640" height="195" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/range.s.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and signals values on-demand (i.e., when requested).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -2931,6 +3204,9 @@ public static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> firs
      * <p>
      * <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/sequenceEqual.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator signals a {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code sequenceEqual} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2965,6 +3241,11 @@ public static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> firs
      * The resulting Observable completes if both the outer Observable and the last inner Observable, if any, complete.
      * If the outer Observable signals an onError, the inner Observable is unsubscribed and the error delivered in-sequence.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The outer {@code Observable} is consumed in an
+     *  unbounded manner (i.e., without backpressure) and the inner {@code Observable}s are expected to honor
+     *  backpressure but it is not enforced; the operator won't signal a {@code MissingBackpressureException}
+     *  but the violation <em>may</em> lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code switchOnNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -2995,6 +3276,11 @@ public static <T> Observable<T> switchOnNext(Observable<? extends Observable<? e
      * If the main Observable signals an onError, the termination of the last inner Observable will emit that error as is
      * or wrapped into a CompositeException along with the other possible errors the former inner Observables signalled.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The outer {@code Observable} is consumed in an
+     *  unbounded manner (i.e., without backpressure) and the inner {@code Observable}s are expected to honor
+     *  backpressure but it is not enforced; the operator won't signal a {@code MissingBackpressureException}
+     *  but the violation <em>may</em> lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code switchOnNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3019,7 +3305,7 @@ public static <T> Observable<T> switchOnNextDelayError(Observable<? extends Obse
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timer.p.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time. If the downstream needs a slower rate
      *      it should slow the timer or use something like {@link #onBackpressureDrop}.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -3048,7 +3334,7 @@ public static Observable<Long> timer(long initialDelay, long period, TimeUnit un
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timer.ps.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time. If the downstream needs a slower rate
      *      it should slow the timer or use something like {@link #onBackpressureDrop}.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -3078,7 +3364,7 @@ public static Observable<Long> timer(long initialDelay, long period, TimeUnit un
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timer.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time. If the downstream needs a slower rate
      *      it should slow the timer or use something like {@link #onBackpressureDrop}.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -3102,7 +3388,7 @@ public static Observable<Long> timer(long delay, TimeUnit unit) {
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timer.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time. If the downstream needs a slower rate
      *      it should slow the timer or use something like {@link #onBackpressureDrop}.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -3853,6 +4139,9 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> zip(Observab
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/all.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded
+     *  manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code all} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3873,6 +4162,9 @@ public final Observable<Boolean> all(Func1<? super T, Boolean> predicate) {
      * <p>
      * <img width="640" height="385" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/amb.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by the winning
+     *  {@code Observable}'s backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3892,6 +4184,9 @@ public final Observable<T> ambWith(Observable<? extends T> t1) {
      * when you have an implementation of a subclass of Observable but you want to hide the properties and
      * methods of this subclass from whomever you are passing the Observable to.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator itself doesn't interfere with backpressure which is determined by this
+     *  {@code Observable}'s backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code asObservable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3909,7 +4204,7 @@ public final Observable<T> asObservable() {
      * <p>
      * <img width="640" height="395" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/buffer1.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it is instead controlled by the given Observables and
      *      buffers data. It requests {@code Long.MAX_VALUE} upstream and does not obey downstream requests.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -3919,7 +4214,7 @@ public final Observable<T> asObservable() {
      * @param <TClosing> the value type of the boundary-providing Observable
      * @param bufferClosingSelector
      *            a {@link Func0} that produces an Observable that governs the boundary between buffers.
-     *            Whenever this {@code Observable} emits an item, {@code buffer} emits the current buffer and
+     *            Whenever the source {@code Observable} emits an item, {@code buffer} emits the current buffer and
      *            begins to fill a new one
      * @return an Observable that emits a connected, non-overlapping buffer of items from the source Observable
      *         each time the Observable created with the {@code bufferClosingSelector} argument emits an item
@@ -3937,6 +4232,10 @@ public final <TClosing> Observable<List<T>> buffer(Func0<? extends Observable<?
      * <p>
      * <img width="640" height="320" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/buffer3.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and expects the source {@code Observable} to honor it as
+     *  well, although not enforced; violation <em>may</em> lead to {@code MissingBackpressureException} somewhere
+     *  downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3959,6 +4258,10 @@ public final Observable<List<T>> buffer(int count) {
      * <p>
      * <img width="640" height="320" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/buffer4.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and expects the source {@code Observable} to honor it as
+     *  well, although not enforced; violation <em>may</em> lead to {@code MissingBackpressureException} somewhere
+     *  downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -3986,7 +4289,7 @@ public final Observable<List<T>> buffer(int count, int skip) {
      * <p>
      * <img width="640" height="320" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/buffer7.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE}
      *      upstream and does not obey downstream requests.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -4016,7 +4319,7 @@ public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit
      * <p>
      * <img width="640" height="320" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/buffer7.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE}
      *      upstream and does not obey downstream requests.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -4047,7 +4350,7 @@ public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit
      * <p>
      * <img width="640" height="320" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/buffer5.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE}
      *      upstream and does not obey downstream requests.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -4076,7 +4379,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit) {
      * <p>
      * <img width="640" height="320" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/buffer6.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE}
      *      upstream and does not obey downstream requests.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -4109,7 +4412,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count)
      * <p>
      * <img width="640" height="320" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/buffer6.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE}
      *      upstream and does not obey downstream requests.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -4143,7 +4446,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count,
      * <p>
      * <img width="640" height="320" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/buffer5.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time. It requests {@code Long.MAX_VALUE}
      *      upstream and does not obey downstream requests.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -4172,7 +4475,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler
      * <p>
      * <img width="640" height="470" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/buffer2.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it is instead controlled by the given Observables and
      *      buffers data. It requests {@code Long.MAX_VALUE} upstream and does not obey downstream requests.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -4203,7 +4506,7 @@ public final <TOpening, TClosing> Observable<List<T>> buffer(Observable<? extend
      * Completion of either the source or the boundary Observable causes the returned Observable to emit the
      * latest buffer and complete.
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it is instead controlled by the {@code Observable}
      *      {@code boundary} and buffers data. It requests {@code Long.MAX_VALUE} upstream and does not obey
      *      downstream requests.</dd>
@@ -4233,7 +4536,7 @@ public final <B> Observable<List<T>> buffer(Observable<B> boundary) {
      * Completion of either the source or the boundary Observable causes the returned Observable to emit the
      * latest buffer and complete.
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it is instead controlled by the {@code Observable}
      *      {@code boundary} and buffers data. It requests {@code Long.MAX_VALUE} upstream and does not obey
      *      downstream requests.</dd>
@@ -4296,7 +4599,7 @@ public final <B> Observable<List<T>> buffer(Observable<B> boundary, int initialC
      *       .subscribe(...);
      * </code></pre>
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator consumes this Observable in an unbounded fashion but respects the backpressure
      *  of each downstream Subscriber individually.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -4364,7 +4667,7 @@ public final Observable<T> cache(int initialCapacity) {
      *       .subscribe(...);
      * </code></pre>
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator consumes this Observable in an unbounded fashion but respects the backpressure
      *  of each downstream Subscriber individually.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -4389,6 +4692,9 @@ public final Observable<T> cacheWithInitialCapacity(int initialCapacity) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/cast.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code cast} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4413,7 +4719,7 @@ public final <R> Observable<R> cast(final Class<R> klass) {
      * <p>
      * This is a simplified version of {@code reduce} that does not need to return the state on each pass.
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure because by intent it will receive all values and reduce
      *      them to a single {@code onNext}.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -4449,6 +4755,12 @@ public final <R> Observable<R> collect(Func0<R> stateFactory, final Action2<R, ?
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concatMap.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. Both this and the inner {@code Observable}s are
+     *  expected to honor backpressure as well. If the source {@code Observable} violates the rule, the operator will
+     *  signal a {@code MissingBackpressureException}. If any of the inner {@code Observable}s doesn't honor
+     *  backpressure, that <em>may</em> throw an {@code IllegalStateException} when that 
+     *  {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4477,7 +4789,11 @@ public final <R> Observable<R> concatMap(Func1<? super T, ? extends Observable<?
      * 
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>{@code concatMapDelayError} fully supports backpressure.</dd>
+     *  <dd>The operator honors backpressure from downstream. Both this and the inner {@code Observable}s are
+     *  expected to honor backpressure as well. If the source {@code Observable} violates the rule, the operator will
+     *  signal a {@code MissingBackpressureException}. If any of the inner {@code Observable}s doesn't honor
+     *  backpressure, that <em>may</em> throw an {@code IllegalStateException} when that 
+     *  {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concatMapDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4501,6 +4817,10 @@ public final <R> Observable<R> concatMapDelayError(Func1<? super T, ? extends Ob
      * <p>
      * 
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s is
+     *  expected to honor backpressure as well. If the source {@code Observable} violates the rule, the operator will
+     *  signal a {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concatMapIterable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4524,6 +4844,10 @@ public final <R> Observable<R> concatMapIterable(Func1<? super T, ? extends Iter
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. Both this and the {@code other} {@code Observable}s
+     *  are expected to honor backpressure as well. If any of then violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4544,6 +4868,9 @@ public final Observable<T> concatWith(Observable<? extends T> t1) {
      * <p>
      * <img width="640" height="320" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/contains.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code contains} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4563,9 +4890,9 @@ public final Observable<Boolean> contains(final Object element) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/count.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure because by intent it will receive all values and reduce
-     *      them to a single {@code onNext}.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code count} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4584,9 +4911,9 @@ public final Observable<Integer> count() {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/longCount.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure because by intent it will receive all values and reduce
-     *      them to a single {@code onNext}.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code countLong} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4606,7 +4933,7 @@ public final Observable<Long> countLong() {
      * <p>
      * <img width="640" height="425" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/debounce.f.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses the {@code debounceSelector} to mark
      *      boundaries.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -4644,7 +4971,7 @@ public final <U> Observable<T> debounce(Func1<? super T, ? extends Observable<U>
      * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
      * </ul>
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code debounce} operates by default on the {@code computation} {@link Scheduler}.</dd>
@@ -4683,7 +5010,7 @@ public final Observable<T> debounce(long timeout, TimeUnit unit) {
      * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
      * </ul>
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
@@ -4713,6 +5040,11 @@ public final Observable<T> debounce(long timeout, TimeUnit unit, Scheduler sched
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/defaultIfEmpty.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>If the source {@code Observable} is empty, this operator is guaranteed to honor backpressure from downstream.
+     *  If the source {@code Observable} is non-empty, it is expected to honor backpressure as well; if the rule is violated,
+     *  a {@code MissingBackpressureException} <em>may</em> get signalled somewhere downstream. 
+     *  </dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code defaultIfEmpty} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4733,6 +5065,12 @@ public final Observable<T> defaultIfEmpty(final T defaultValue) {
      * Observable if the source Observable is empty.
      * <p/>
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>If the source {@code Observable} is empty, the alternate {@code Observable} is expected to honor backpressure.
+     *  If the source {@code Observable} is non-empty, it is expected to honor backpressure as instead.
+     *  In either case, if violated, a {@code MissingBackpressureException} <em>may</em> get 
+     *  signalled somewhere downstream.
+     *  </dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code switchIfEmpty} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4756,6 +5094,10 @@ public final Observable<T> switchIfEmpty(Observable<? extends T> alternate) {
      * <em>Note:</em> the resulting Observable will immediately propagate any {@code onError} notification
      * from the source Observable.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}. 
+     *  All of the other {@code Observable}s supplied by the functions are consumed
+     *  in an unbounded manner (i.e., no backpressure applied to them).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code delay} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4790,6 +5132,10 @@ public final <U, V> Observable<T> delay(
      * <em>Note:</em> the resulting Observable will immediately propagate any {@code onError} notification
      * from the source Observable.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}. 
+     *  All of the other {@code Observable}s supplied by the function are consumed
+     *  in an unbounded manner (i.e., no backpressure applied to them).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code delay} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4814,6 +5160,8 @@ public final <U> Observable<T> delay(Func1<? super T, ? extends Observable<U>> i
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/delay.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code delay} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -4835,6 +5183,8 @@ public final Observable<T> delay(long delay, TimeUnit unit) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/delay.s.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -4857,6 +5207,8 @@ public final Observable<T> delay(long delay, TimeUnit unit, Scheduler scheduler)
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/delaySubscription.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code delay} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -4878,6 +5230,8 @@ public final Observable<T> delaySubscription(long delay, TimeUnit unit) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/delaySubscription.s.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -4902,6 +5256,10 @@ public final Observable<T> delaySubscription(long delay, TimeUnit unit, Schedule
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/delaySubscription.o.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}. 
+     *  The other {@code Observable}s supplied by the function is consumed in an unbounded manner 
+     *  (i.e., no backpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This method does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4951,6 +5309,9 @@ public final <U> Observable<T> delaySubscription(Observable<U> other) {
      * <p>
      * <img width="640" height="335" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/dematerialize.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code dematerialize} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4972,6 +5333,9 @@ public final <T2> Observable<T2> dematerialize() {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/distinct.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code distinct} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -4990,6 +5354,9 @@ public final Observable<T> distinct() {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/distinct.key.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code distinct} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5011,6 +5378,9 @@ public final <U> Observable<T> distinct(Func1<? super T, ? extends U> keySelecto
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/distinctUntilChanged.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5029,6 +5399,9 @@ public final Observable<T> distinctUntilChanged() {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/distinctUntilChanged.key.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5051,6 +5424,9 @@ public final <U> Observable<T> distinctUntilChanged(Func1<? super T, ? extends U
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/distinctUntilChanged.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5073,6 +5449,9 @@ public final Observable<T> distinctUntilChanged(Func2<? super T, ? super T, Bool
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/doOnCompleted.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnCompleted} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5095,6 +5474,9 @@ public final Observable<T> doOnCompleted(final Action0 onCompleted) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/doOnEach.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnEach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5120,6 +5502,9 @@ public final Observable<T> doOnEach(final Action1<Notification<? super T>> onNot
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/doOnEach.o.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnEach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5142,6 +5527,9 @@ public final Observable<T> doOnEach(Observer<? super T> observer) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/doOnError.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5164,6 +5552,9 @@ public final Observable<T> doOnError(final Action1<Throwable> onError) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/doOnNext.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5188,6 +5579,9 @@ public final Observable<T> doOnNext(final Action1<? super T> onNext) {
      * <b>Note:</b> This operator is for tracing the internal behavior of back-pressure request
      * patterns and generally intended for debugging use.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code doOnRequest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5214,12 +5608,15 @@ public final Observable<T> doOnRequest(final Action1<Long> onRequest) {
      * <p>
      * <img width="640" height="390" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/doOnSubscribe.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnSubscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
      * @param subscribe
-     *            the action that gets called when an observer subscribes to this {@code Observable}
+     *            the action that gets called when an observer subscribes to the source {@code Observable}
      * @return the source {@code Observable} modified so as to call this Action when appropriate
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
      */
@@ -5236,6 +5633,9 @@ public final Observable<T> doOnSubscribe(final Action0 subscribe) {
      * This differs from {@code finallyDo} in that this happens <em>before</em> the {@code onCompleted} or
      * {@code onError} notification.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s
+     *  backpressure behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnTerminate} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5276,7 +5676,7 @@ public final Observable<T> doOnTerminate(final Action0 onTerminate) {
      * </dl>
      *
      * @param unsubscribe
-     *            the action that gets called when this {@code Observable} is unsubscribed
+     *            the action that gets called when the source {@code Observable} is unsubscribed
      * @return the source {@code Observable} modified so as to call this Action when appropriate
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
      */
@@ -5733,6 +6133,9 @@ public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observa
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/elementAt.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded manner
+     *  (i.e., no backkpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code elementAt} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5757,6 +6160,9 @@ public final Observable<T> elementAt(int index) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/elementAtOrDefault.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded manner
+     *  (i.e., no backkpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code elementAtOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5785,6 +6191,9 @@ public final Observable<T> elementAtOrDefault(int index, T defaultValue) {
      * In Rx.Net this is the {@code any} Observer but we renamed it in RxJava to better match Java naming
      * idioms.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded manner
+     *  (i.e., no backkpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code exists} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5804,6 +6213,9 @@ public final Observable<Boolean> exists(Func1<? super T, Boolean> predicate) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/filter.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code filter} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5825,6 +6237,9 @@ public final Observable<T> filter(Func1<? super T, Boolean> predicate) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/finallyDo.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code finallyDo} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5848,6 +6263,9 @@ public final Observable<T> finallyDo(Action0 action) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/finallyDo.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doAfterTerminate} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5869,6 +6287,9 @@ public final Observable<T> doAfterTerminate(Action0 action) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/first.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code first} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5887,6 +6308,9 @@ public final Observable<T> first() {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/firstN.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code first} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5907,6 +6331,9 @@ public final Observable<T> first(Func1<? super T, Boolean> predicate) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/firstOrDefault.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code firstOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5927,6 +6354,9 @@ public final Observable<T> firstOrDefault(T defaultValue) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/firstOrDefaultN.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code firstOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5951,6 +6381,10 @@ public final Observable<T> firstOrDefault(T defaultValue, Func1<? super T, Boole
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/flatMap.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The outer {@code Observable} is consumed
+     *  in unbounded mode (i.e., no backpressure is applied to it). The inner {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -5979,6 +6413,9 @@ public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? e
      * <p>
      * <!-- <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/flatMap.png" alt=""> -->
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. Both the outer and inner {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6009,6 +6446,10 @@ public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? e
      * <p>
      * <img width="640" height="410" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/mergeMap.nce.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The outer {@code Observable} is consumed
+     *  in unbounded mode (i.e., no backpressure is applied to it). The inner {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6040,6 +6481,9 @@ public final <R> Observable<R> flatMap(
      * <p>
      * <!-- <img width="640" height="410" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/mergeMap.nce.png" alt=""> -->
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. Both the outer and inner {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6075,6 +6519,9 @@ public final <R> Observable<R> flatMap(
      * <p>
      * <img width="640" height="390" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/mergeMap.r.png" alt="">
      * <dl>
+     *  <dd>The operator honors backpressure from downstream. The outer {@code Observable} is consumed
+     *  in unbounded mode (i.e., no backpressure is applied to it). The inner {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6103,6 +6550,9 @@ public final <U, R> Observable<R> flatMap(final Func1<? super T, ? extends Obser
      * <p>
      * <!-- <img width="640" height="390" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/mergeMap.r.png" alt=""> -->
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. Both the outer and inner {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6135,6 +6585,10 @@ public final <U, R> Observable<R> flatMap(final Func1<? super T, ? extends Obser
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/mergeMapIterable.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s is
+     *  expected to honor backpressure as well. If the source {@code Observable} violates the rule, the operator will
+     *  signal a {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6159,6 +6613,10 @@ public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterab
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/mergeMapIterable.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s is
+     *  expected to honor backpressure as well. If the source {@code Observable} violates the rule, the operator will
+     *  signal a {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6188,6 +6646,9 @@ public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterab
      * <p>
      * <img width="640" height="390" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/mergeMapIterable.r.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and the source {@code Observable}s is
+     *  consumed in an unbounded manner (i.e., no backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6219,6 +6680,10 @@ public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Ite
      * <p>
      * <img width="640" height="390" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/mergeMapIterable.r.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s is
+     *  expected to honor backpressure as well. If the source {@code Observable} violates the rule, the operator will
+     *  signal a {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6254,6 +6719,9 @@ public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Ite
      * <p>
      * Alias to {@link #subscribe(Action1)}
      * <dl>
+     *  <dd><b>Backpressure:</b><dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner (i.e., no
+     *  backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code forEach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6275,6 +6743,9 @@ public final void forEach(final Action1<? super T> onNext) {
      * <p>
      * Alias to {@link #subscribe(Action1, Action1)}
      * <dl>
+     *  <dd><b>Backpressure:</b><dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner (i.e., no
+     *  backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code forEach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6299,6 +6770,9 @@ public final void forEach(final Action1<? super T> onNext, final Action1<Throwab
      * <p>
      * Alias to {@link #subscribe(Action1, Action1, Action0)}
      * <dl>
+     *  <dd><b>Backpressure:</b><dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner (i.e., no
+     *  backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code forEach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6335,6 +6809,12 @@ public final void forEach(final Action1<? super T> onNext, final Action1<Throwab
      * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may
      * discard their buffers by applying an operator like {@link #ignoreElements} to them.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>Both the returned and its inner {@code Observable}s honor backpressure and the source {@code Observable}
+     *  is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on
+     *  downstream consumption). Note that both the returned and its inner {@code Observable}s use
+     *  unbounded internal buffers and if the source {@code Observable} doesn't honor backpressure, that <em>may</em>
+     *  lead to {@code OutOfMemoryError}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code groupBy} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6370,6 +6850,12 @@ public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? su
      * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may
      * discard their buffers by applying an operator like {@link #ignoreElements} to them.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>Both the returned and its inner {@code Observable}s honor backpressure and the source {@code Observable}
+     *  is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on
+     *  downstream consumption). Note that both the returned and its inner {@code Observable}s use
+     *  unbounded internal buffers and if the source {@code Observable} doesn't honor backpressure, that <em>may</em>
+     *  lead to {@code OutOfMemoryError}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code groupBy} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6429,6 +6915,12 @@ public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? su
      * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may
      * discard their buffers by applying an operator like {@link #ignoreElements} to them.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>Both the returned and its inner {@code Observable}s honor backpressure and the source {@code Observable}
+     *  is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on
+     *  downstream consumption). Note that both the returned and its inner {@code Observable}s use
+     *  unbounded internal buffers and if the source {@code Observable} doesn't honor backpressure, that <em>may</em>
+     *  lead to {@code OutOfMemoryError}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code groupBy} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6454,6 +6946,9 @@ public final <K> Observable<GroupedObservable<K, T>> groupBy(final Func1<? super
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/groupJoin.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't support backpressure and consumes all participating {@code Observable}s in
+     *  an unbounded mode (i.e., not applying any backpressure to them).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code groupJoin} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6488,6 +6983,9 @@ public final <T2, D1, D2, R> Observable<R> groupJoin(Observable<T2> right, Func1
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/ignoreElements.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator ignores backpressure as it doesn't emit any elements and consumes the source {@code Observable}
+     *  in an unbounded manner (i.e., no backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code ignoreElements} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6508,6 +7006,9 @@ public final Observable<T> ignoreElements() {
      * <p>
      * <img width="640" height="320" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/isEmpty.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code isEmpty} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6527,6 +7028,9 @@ public final Observable<Boolean> isEmpty() {
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/join_.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't support backpressure and consumes all participating {@code Observable}s in
+     *  an unbounded mode (i.e., not applying any backpressure to them).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code join} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6562,6 +7066,9 @@ public final <TRight, TLeftDuration, TRightDuration, R> Observable<R> join(Obser
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/last.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code last} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6580,6 +7087,9 @@ public final Observable<T> last() {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/last.p.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code last} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6602,6 +7112,9 @@ public final Observable<T> last(Func1<? super T, Boolean> predicate) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/lastOrDefault.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code lastOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6622,6 +7135,9 @@ public final Observable<T> lastOrDefault(T defaultValue) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/lastOrDefault.p.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code lastOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6650,6 +7166,10 @@ public final Observable<T> lastOrDefault(T defaultValue, Func1<? super T, Boolea
      * {@link Observer#onNext onNext} function a maximum of {@code count} times before invoking
      * {@link Observer#onCompleted onCompleted}.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior in case the first request is smaller than the {@code count}. Otherwise, the source {@code Observable}
+     *  is consumed in an unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code limit} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6670,6 +7190,9 @@ public final Observable<T> limit(int count) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/map.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code map} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6695,6 +7218,9 @@ private <R> Observable<R> mapNotification(Func1<? super T, ? extends R> onNext,
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/materialize.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and expects it from the source {@code Observable}.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code materialize} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6715,6 +7241,9 @@ public final Observable<Notification<T>> materialize() {
      * You can combine items emitted by multiple Observables so that they appear as a single Observable, by
      * using the {@code mergeWith} method.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. This and the other {@code Observable}s are expected to honor
+     *  backpressure; if violated, the operator <em>may</em> signal {@code MissingBackpressureException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6737,6 +7266,12 @@ public final Observable<T> mergeWith(Observable<? extends T> t1) {
      * <p>
      * <img width="640" height="308" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/observeOn.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator honors backpressure from downstream and expects it from the source {@code Observable}. Violating this
+     *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
+     *  pops up; look for sources up the chain that don't support backpressure, 
+     *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
+     *  of the {@code onBackpressureXXX} operators <strong>before</strong> applying {@code observeOn} itself.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -6765,6 +7300,12 @@ public final Observable<T> observeOn(Scheduler scheduler) {
      * <p>
      * <img width="640" height="308" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/observeOn.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator honors backpressure from downstream and expects it from the source {@code Observable}. Violating this
+     *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
+     *  pops up; look for sources up the chain that don't support backpressure, 
+     *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
+     *  of the {@code onBackpressureXXX} opertors <strong>before</strong> applying {@code observeOn} itself.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -6790,6 +7331,12 @@ public final Observable<T> observeOn(Scheduler scheduler, int bufferSize) {
      * <p>
      * <img width="640" height="308" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/observeOn.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator honors backpressure from downstream and expects it from the source {@code Observable}. Violating this
+     *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
+     *  pops up; look for sources up the chain that don't support backpressure, 
+     *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
+     *  of the {@code onBackpressureXXX} opertors <strong>before</strong> applying {@code observeOn} itself.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -6819,6 +7366,12 @@ public final Observable<T> observeOn(Scheduler scheduler, boolean delayError) {
      * <p>
      * <img width="640" height="308" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/observeOn.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator honors backpressure from downstream and expects it from the source {@code Observable}. Violating this
+     *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
+     *  pops up; look for sources up the chain that don't support backpressure, 
+     *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
+     *  of the {@code onBackpressureXXX} opertors <strong>before</strong> applying {@code observeOn} itself.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -6851,6 +7404,9 @@ public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, in
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/ofClass.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code ofType} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6871,6 +7427,9 @@ public final <R> Observable<R> ofType(final Class<R> klass) {
      * <p>
      * <img width="640" height="300" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/bp.obp.buffer.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded
+     *  manner (i.e., not applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onBackpressureBuffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6890,6 +7449,9 @@ public final Observable<T> onBackpressureBuffer() {
      * <p>
      * <img width="640" height="300" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/bp.obp.buffer.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded
+     *  manner (i.e., not applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onBackpressureBuffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6911,6 +7473,9 @@ public final Observable<T> onBackpressureBuffer(long capacity) {
      * <p>
      * <img width="640" height="300" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/bp.obp.buffer.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded
+     *  manner (i.e., not applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onBackpressureBuffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6944,6 +7509,9 @@ public final Observable<T> onBackpressureBuffer(long capacity, Action0 onOverflo
      * <p>
      * <img width="640" height="300" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/bp.obp.buffer.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded
+     *  manner (i.e., not applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onBackpressureBuffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6969,6 +7537,9 @@ public final Observable<T> onBackpressureBuffer(long capacity, Action0 onOverflo
      * If the downstream request count hits 0 then the Observable will refrain from calling {@code onNext} until
      * the observer invokes {@code request(n)} again to increase the request count.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded
+     *  manner (i.e., not applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onBackpressureDrop} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6992,6 +7563,9 @@ public final Observable<T> onBackpressureDrop(Action1<? super T> onDrop) {
      * If the downstream request count hits 0 then the Observable will refrain from calling {@code onNext} until
      * the observer invokes {@code request(n)} again to increase the request count.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded
+     *  manner (i.e., not applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onBackpressureDrop} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -7017,6 +7591,14 @@ public final Observable<T> onBackpressureDrop() {
      * <p>
      * Note that due to the nature of how backpressure requests are propagated through subscribeOn/observeOn,
      * requesting more than 1 from downstream doesn't guarantee a continuous delivery of onNext events.
+     * <p>
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded
+     *  manner (i.e., not applying backpressure to it).</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code onBackpressureLatest} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
      *
      * @return the source Observable modified so that it emits the most recently-received item upon request
      * @since 1.1.0
@@ -7044,6 +7626,12 @@ public final Observable<T> onBackpressureLatest() {
      * You can use this to prevent errors from propagating or to supply fallback data should errors be
      * encountered.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. This and the resuming {@code Observable}s
+     *  are expected to honor backpressure as well. 
+     *  If any of them violate this expectation, the operator <em>may</em> throw an 
+     *  {@code IllegalStateException} when the source {@code Observable} completes or
+     *  a {@code MissingBackpressureException} is signalled somewhere downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -7077,6 +7665,12 @@ public final Observable<T> onErrorResumeNext(final Func1<Throwable, ? extends Ob
      * You can use this to prevent errors from propagating or to supply fallback data should errors be
      * encountered.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. This and the resuming {@code Observable}s
+     *  are expected to honor backpressure as well. 
+     *  If any of them violate this expectation, the operator <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes or
+     *  {@code MissingBackpressureException} is signalled somewhere downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -7108,6 +7702,11 @@ public final Observable<T> onErrorResumeNext(final Observable<? extends T> resum
      * You can use this to prevent errors from propagating or to supply fallback data should errors be
      * encountered.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s is expected to honor 
+     *  backpressure as well. If it this expectation is violated, the operator <em>may</em> throw 
+     *  {@code IllegalStateException} when the source {@code Observable} completes or
+     *  {@code MissingBackpressureException} is signalled somewhere downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onErrorReturn} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -7145,6 +7744,12 @@ public final Observable<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFun
      * You can use this to prevent exceptions from propagating or to supply fallback data should exceptions be
      * encountered.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. This and the resuming {@code Observable}s
+     *  are expected to honor backpressure as well. 
+     *  If any of them violate this expectation, the operator <em>may</em> throw an 
+     *  {@code IllegalStateException} when the source {@code Observable} completes or
+     *  {@code MissingBackpressureException} is signalled somewhere downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onExceptionResumeNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -7165,6 +7770,9 @@ public final Observable<T> onExceptionResumeNext(final Observable<? extends T> r
      * Nulls out references to the upstream producer and downstream Subscriber if
      * the sequence is terminated or downstream unsubscribes.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onTerminateDetach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -7184,6 +7792,10 @@ public final Observable<T> onTerminateDetach() {
      * <p>
      * <img width="640" height="510" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/publishConnect.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The returned {@code ConnectableObservable} honors backpressure for each of its {@code Subscriber}s
+     *  and expects the source {@code Observable} to honor backpressure as well. If this expectation is violated,
+     *  the operator will signal a {@code MissingBackpressureException} to its {@code Subscriber}s and disconnect.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code publish} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -7202,6 +7814,12 @@ public final ConnectableObservable<T> publish() {
      * <p>
      * <img width="640" height="510" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/publishConnect.f.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator expects the source {@code Observable} to honor backpressure and if this expectation is
+     *  violated, the operator will signal a {@code MissingBackpressureException} through the {@code Observable}
+     *  provided to the function. Since the {@code Observable} returned by the {@code selector} may be
+     *  independent from the provided {@code Observable} to the function, the output's backpressure behavior
+     *  is determined by this returned {@code Observable}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code publish} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -7257,7 +7875,7 @@ public final Observable<T> rebatchRequests(int n) {
      * "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code inject} method
      * that does a similar operation on lists.
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure of its downstream consumer and consumes the
      *  upstream source in unbounded mode.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -7310,7 +7928,7 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
      * );
      * </code></pre>
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure of its downstream consumer and consumes the
      *  upstream source in unbounded mode.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -7337,6 +7955,9 @@ public final <R> Observable<R> reduce(R initialValue, Func2<R, ? super T, R> acc
      * <p>
      * <img width="640" height="309" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/repeat.o.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code repeat} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
@@ -7354,6 +7975,9 @@ public final Observable<T> repeat() {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/repeat.os.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -7373,6 +7997,9 @@ public final Observable<T> repeat(Scheduler scheduler) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/repeat.on.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code repeat} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
@@ -7396,6 +8023,9 @@ public final Observable<T> repeat(final long count) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/repeat.ons.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -7423,6 +8053,9 @@ public final Observable<T> repeat(final long count, Scheduler scheduler) {
      * <p>
      * <img width="640" height="430" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/repeatWhen.f.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -7448,6 +8081,9 @@ public final Observable<T> repeatWhen(final Func1<? super Observable<? extends V
      * <p>
      * <img width="640" height="430" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/repeatWhen.f.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code repeatWhen} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
@@ -7469,7 +8105,7 @@ public final Observable<T> repeatWhen(final Func1<? super Observable<? extends V
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7491,7 +8127,7 @@ public final ConnectableObservable<T> replay() {
      * <p>
      * <img width="640" height="450" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.f.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7519,7 +8155,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      * <p>
      * <img width="640" height="440" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.fn.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7550,7 +8186,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      * <p>
      * <img width="640" height="445" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.fnt.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7586,7 +8222,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      * <p>
      * <img width="640" height="445" height="440" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.fnts.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7630,7 +8266,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      * <p>
      * <img width="640" height="440" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.fns.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7664,7 +8300,7 @@ public final <R> Observable<R> replay(final Func1<? super Observable<T>, ? exten
      * <p>
      * <img width="640" height="435" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.ft.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7697,7 +8333,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      * <p>
      * <img width="640" height="440" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.fts.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7732,7 +8368,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      * <p>
      * <img width="640" height="445" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.fs.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7766,7 +8402,7 @@ public final <R> Observable<R> replay(final Func1<? super Observable<T>, ? exten
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.n.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7792,7 +8428,7 @@ public final ConnectableObservable<T> replay(final int bufferSize) {
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.nt.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7823,7 +8459,7 @@ public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.nts.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7861,7 +8497,7 @@ public final ConnectableObservable<T> replay(final int bufferSize, final long ti
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.ns.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7889,7 +8525,7 @@ public final ConnectableObservable<T> replay(final int bufferSize, final Schedul
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.t.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7917,7 +8553,7 @@ public final ConnectableObservable<T> replay(long time, TimeUnit unit) {
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.ts.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7947,7 +8583,7 @@ public final ConnectableObservable<T> replay(final long time, final TimeUnit uni
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator supports backpressure. Note that the upstream requests are determined by the child
      *  Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will
      *  request 100 elements from the underlying Observable sequence.</dd>
@@ -7980,6 +8616,9 @@ public final ConnectableObservable<T> replay(final Scheduler scheduler) {
      * {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence
      * of emissions and notifications would be {@code [1, 2, 1, 2, 3, 4, 5, onCompleted]}.
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code retry} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
@@ -8006,6 +8645,9 @@ public final Observable<T> retry() {
      * {@code [1, 2]} then succeeds the second time and emits {@code [1, 2, 3, 4, 5]} then the complete sequence
      * of emissions and notifications would be {@code [1, 2, 1, 2, 3, 4, 5, onCompleted]}.
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code retry} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
@@ -8025,8 +8667,9 @@ public final Observable<T> retry(final long count) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/retry.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator honors backpressure.</td>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code retry} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
@@ -8080,6 +8723,9 @@ public final Observable<T> retry(Func2<Integer, Throwable, Boolean> predicate) {
      * subscribing
      * } </pre>
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code retryWhen} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
@@ -8105,6 +8751,9 @@ public final Observable<T> retryWhen(final Func1<? super Observable<? extends Th
      * <img width="640" height="430" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/retryWhen.f.png" alt="">
      * <p>
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator <em>may</em> throw an {@code IllegalStateException}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -8127,7 +8776,7 @@ public final Observable<T> retryWhen(final Func1<? super Observable<? extends Th
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/sample.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code sample} operates by default on the {@code computation} {@link Scheduler}.</dd>
@@ -8153,7 +8802,7 @@ public final Observable<T> sample(long period, TimeUnit unit) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/sample.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
@@ -8182,7 +8831,7 @@ public final Observable<T> sample(long period, TimeUnit unit, Scheduler schedule
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/sample.o.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses the emissions of the {@code sampler}
      *      Observable to control data flow.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -8211,6 +8860,9 @@ public final <U> Observable<T> sample(Observable<U> sampler) {
      * <p>
      * This sort of function is sometimes called an accumulator.
      * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  Violating this expectation, a {@code MissingBackpressureException} <em>may</em> get signalled somewhere downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code scan} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8253,8 +8905,9 @@ public final Observable<T> scan(Func2<T, T, T> accumulator) {
      * );
      * </code></pre>
      * <dl>
-     *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator honors backpressure.</dd>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The operator honors downstream backpressure and expects the source {@code Observable} to honor backpressure as well.
+     *  Violating this expectation, a {@code MissingBackpressureException} <em>may</em> get signalled somewhere downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code scan} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8286,6 +8939,9 @@ public final <R> Observable<R> scan(R initialValue, Func2<R, ? super T, R> accum
      * <p>
      * <img width="640" height="400" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/synchronize.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code serialize} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8307,10 +8963,10 @@ public final Observable<T> serialize() {
      * <p>
      * <img width="640" height="510" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/publishRefCount.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure because multicasting means the stream is "hot" with
-     *      multiple subscribers. Each child will need to manage backpressure independently using operators such
-     *      as {@link #onBackpressureDrop} and {@link #onBackpressureBuffer}.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure and and expects the source {@code Observable} to honor backpressure as well. 
+     *  If this expectation is violated, the operator will signal a {@code MissingBackpressureException} to 
+     *  its {@code Subscriber}s.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code share} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8330,6 +8986,9 @@ public final Observable<T> share() {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/single.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code single} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8353,6 +9012,9 @@ public final Observable<T> single() {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/single.p.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code single} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8378,6 +9040,9 @@ public final Observable<T> single(Func1<? super T, Boolean> predicate) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/singleOrDefault.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code singleOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8402,6 +9067,9 @@ public final Observable<T> singleOrDefault(T defaultValue) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/singleOrDefault.p.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code singleOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8426,6 +9094,9 @@ public final Observable<T> singleOrDefault(T defaultValue, Func1<? super T, Bool
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/skip.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code skip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8446,6 +9117,9 @@ public final Observable<T> skip(int count) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/skip.t.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't support backpressure as it uses time to skip arbitrary number of elements and
+     *  thus has to consume the source {@code Observable} in an unbounded manner (i.e., no backpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code skip} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -8468,6 +9142,9 @@ public final Observable<T> skip(long time, TimeUnit unit) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/skip.ts.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't support backpressure as it uses time to skip arbitrary number of elements and
+     *  thus has to consume the source {@code Observable} in an unbounded manner (i.e., no backpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -8496,6 +9173,9 @@ public final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler) {
      * received, items are taken from the front of the queue and emitted by the returned Observable. This causes
      * such items to be delayed.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code skipLast} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8520,6 +9200,9 @@ public final Observable<T> skipLast(int count) {
      * <p>
      * Note: this action will cache the latest items arriving in the specified time window.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't support backpressure as it uses time to skip arbitrary number of elements and
+     *  thus has to consume the source {@code Observable} in an unbounded manner (i.e., no backpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code skipLast} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -8544,6 +9227,9 @@ public final Observable<T> skipLast(long time, TimeUnit unit) {
      * <p>
      * Note: this action will cache the latest items arriving in the specified time window.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't support backpressure as it uses time to skip arbitrary number of elements and
+     *  thus has to consume the source {@code Observable} in an unbounded manner (i.e., no backpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -8568,6 +9254,9 @@ public final Observable<T> skipLast(long time, TimeUnit unit, Scheduler schedule
      * <p>
      * <img width="640" height="375" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/skipUntil.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code skipUntil} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8590,6 +9279,9 @@ public final <U> Observable<T> skipUntil(Observable<U> other) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/skipWhile.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code skipWhile} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8610,6 +9302,10 @@ public final Observable<T> skipWhile(Func1<? super T, Boolean> predicate) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/startWith.o.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. Both this and the {@code other} {@code Observable}s
+     *  are expected to honor backpressure as well. If any of then violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8630,6 +9326,10 @@ public final Observable<T> startWith(Observable<T> values) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/startWith.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}
+     *  is expected to honor backpressure as well. If it violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8650,6 +9350,10 @@ public final Observable<T> startWith(Iterable<T> values) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/startWith.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}
+     *  is expected to honor backpressure as well. If it violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8670,6 +9374,10 @@ public final Observable<T> startWith(T t1) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/startWith.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}
+     *  is expected to honor backpressure as well. If it violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8692,6 +9400,10 @@ public final Observable<T> startWith(T t1, T t2) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/startWith.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}
+     *  is expected to honor backpressure as well. If it violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8716,6 +9428,10 @@ public final Observable<T> startWith(T t1, T t2, T t3) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/startWith.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}
+     *  is expected to honor backpressure as well. If it violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8742,6 +9458,10 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/startWith.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}
+     *  is expected to honor backpressure as well. If it violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8770,6 +9490,10 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/startWith.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}
+     *  is expected to honor backpressure as well. If it violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8800,6 +9524,10 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/startWith.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}
+     *  is expected to honor backpressure as well. If it violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8832,6 +9560,10 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/startWith.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}
+     *  is expected to honor backpressure as well. If it violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8866,6 +9598,10 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/startWith.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}
+     *  is expected to honor backpressure as well. If it violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8900,6 +9636,9 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      * Subscribes to an Observable and ignores {@code onNext} and {@code onCompleted} emissions. If an {@code onError} emission arrives then 
      * {@link OnErrorNotImplementedException} is thrown. 
      * <dl>
+     *  <dd><b>Backpressure:</b><dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner (i.e., no
+     *  backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8920,6 +9659,9 @@ public final Subscription subscribe() {
     /**
      * Subscribes to an Observable and provides a callback to handle the items it emits.
      * <dl>
+     *  <dd><b>Backpressure:</b><dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner (i.e., no
+     *  backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8948,6 +9690,9 @@ public final Subscription subscribe(final Action1<? super T> onNext) {
      * Subscribes to an Observable and provides callbacks to handle the items it emits and any error
      * notification it issues.
      * <dl>
+     *  <dd><b>Backpressure:</b><dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner (i.e., no
+     *  backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -8980,6 +9725,9 @@ public final Subscription subscribe(final Action1<? super T> onNext, final Actio
      * Subscribes to an Observable and provides callbacks to handle the items it emits and any error or
      * completion notification it issues.
      * <dl>
+     *  <dd><b>Backpressure:</b><dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner (i.e., no
+     *  backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9018,6 +9766,9 @@ public final Subscription subscribe(final Action1<? super T> onNext, final Actio
      * Subscribes to an Observable and provides an Observer that implements functions to handle the items the
      * Observable emits and any error or completion notification it issues.
      * <dl>
+     *  <dd><b>Backpressure:</b><dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner (i.e., no
+     *  backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9044,6 +9795,9 @@ public final Subscription subscribe(final Observer<? super T> observer) {
      * <a href="http://reactivex.io/documentation/contract.html">the Observable contract</a> and other
      * functionality.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code unsafeSubscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9099,6 +9853,9 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
      * For more information see the
      * <a href="http://reactivex.io/documentation/observable.html">ReactiveX documentation</a>.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9183,6 +9940,9 @@ static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/subscribeOn.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -9212,6 +9972,11 @@ public final Observable<T> subscribeOn(Scheduler scheduler) {
      * <p>
      * <img width="640" height="350" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/switchMap.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The outer {@code Observable} is consumed in an
+     *  unbounded manner (i.e., without backpressure) and the inner {@code Observable}s are expected to honor
+     *  backpressure but it is not enforced; the operator won't signal a {@code MissingBackpressureException}
+     *  but the violation <em>may</em> lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code switchMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9238,6 +10003,11 @@ public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<?
      * <p>
      * <img width="640" height="350" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/switchMap.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The outer {@code Observable} is consumed in an
+     *  unbounded manner (i.e., without backpressure) and the inner {@code Observable}s are expected to honor
+     *  backpressure but it is not enforced; the operator won't signal a {@code MissingBackpressureException}
+     *  but the violation <em>may</em> lead to {@code OutOfMemoryError} due to internal buffer bloat.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code switchMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9266,6 +10036,10 @@ public final <R> Observable<R> switchMapDelayError(Func1<? super T, ? extends Ob
      * {@link Observer#onNext onNext} function a maximum of {@code count} times before invoking
      * {@link Observer#onCompleted onCompleted}.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior in case the first request is smaller than the {@code count}. Otherwise, the source {@code Observable}
+     *  is consumed in an unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code take} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9286,6 +10060,9 @@ public final Observable<T> take(final int count) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/take.t.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code take} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -9307,6 +10084,9 @@ public final Observable<T> take(long time, TimeUnit unit) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/take.ts.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -9331,6 +10111,9 @@ public final Observable<T> take(long time, TimeUnit unit, Scheduler scheduler) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeFirstN.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code takeFirst} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9352,6 +10135,9 @@ public final Observable<T> takeFirst(Func1<? super T, Boolean> predicate) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLast.n.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream if the {@code count} is non-zero; ignores
+     *  backpressure if the {@code count} is zero as it doesn't signal any values.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLast} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9380,6 +10166,9 @@ public final Observable<T> takeLast(final int count) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLast.tn.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., no backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLast} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -9405,6 +10194,9 @@ public final Observable<T> takeLast(int count, long time, TimeUnit unit) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLast.tns.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., no backpressure is applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -9434,6 +10226,12 @@ public final Observable<T> takeLast(int count, long time, TimeUnit unit, Schedul
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLast.t.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., no backpressure is applied to it) but note that this <em>may</em>
+     *  lead to {@code OutOfMemoryError} due to internal buffer bloat. 
+     *  Consider using {@link #takeLast(int, long, TimeUnit)} in this case.</dd>
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLast} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -9457,6 +10255,11 @@ public final Observable<T> takeLast(long time, TimeUnit unit) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLast.ts.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., no backpressure is applied to it) but note that this <em>may</em>
+     *  lead to {@code OutOfMemoryError} due to internal buffer bloat. 
+     *  Consider using {@link #takeLast(int, long, TimeUnit, Scheduler)} in this case.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -9482,6 +10285,9 @@ public final Observable<T> takeLast(long time, TimeUnit unit, Scheduler schedule
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLastBuffer.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLastBuffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9502,6 +10308,9 @@ public final Observable<List<T>> takeLastBuffer(int count) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLastBuffer.tn.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLastBuffer} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -9528,6 +10337,9 @@ public final Observable<List<T>> takeLastBuffer(int count, long time, TimeUnit u
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLastBuffer.tns.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -9555,6 +10367,9 @@ public final Observable<List<T>> takeLastBuffer(int count, long time, TimeUnit u
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLastBuffer.t.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLastBuffer} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -9578,6 +10393,9 @@ public final Observable<List<T>> takeLastBuffer(long time, TimeUnit unit) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLastBuffer.ts.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -9603,6 +10421,9 @@ public final Observable<List<T>> takeLastBuffer(long time, TimeUnit unit, Schedu
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeUntil.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code takeUntil} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9625,6 +10446,9 @@ public final <E> Observable<T> takeUntil(Observable<? extends E> other) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeWhile.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code takeWhile} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -9678,7 +10502,7 @@ public final Observable<T> takeUntil(final Func1<? super T, Boolean> stopPredica
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/throttleFirst.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code throttleFirst} operates by default on the {@code computation} {@link Scheduler}.</dd>
@@ -9705,7 +10529,7 @@ public final Observable<T> throttleFirst(long windowDuration, TimeUnit unit) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/throttleFirst.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
@@ -9735,7 +10559,7 @@ public final Observable<T> throttleFirst(long skipDuration, TimeUnit unit, Sched
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/throttleLast.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code throttleLast} operates by default on the {@code computation} {@link Scheduler}.</dd>
@@ -9764,7 +10588,7 @@ public final Observable<T> throttleLast(long intervalDuration, TimeUnit unit) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/throttleLast.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
@@ -9804,7 +10628,7 @@ public final Observable<T> throttleLast(long intervalDuration, TimeUnit unit, Sc
      * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
      * </ul>
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code throttleWithTimeout} operates by default on the {@code computation} {@link Scheduler}.</dd>
@@ -9843,7 +10667,7 @@ public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit) {
      * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
      * </ul>
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
@@ -9873,6 +10697,9 @@ public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit, Sche
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timeInterval.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code timeInterval} operates by default on the {@code immediate} {@link Scheduler}.</dd>
      * </dl>
@@ -9890,6 +10717,9 @@ public final Observable<TimeInterval<T>> timeInterval() {
      * <p>
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timeInterval.s.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -9910,6 +10740,10 @@ public final Observable<TimeInterval<T>> timeInterval(Scheduler scheduler) {
      * <p>
      * <img width="640" height="400" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timeout5.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. Both this and the returned {@code Observable}s
+     *  are expected to honor backpressure as well. If any of then violates this rule, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.</dd>
      * </dl>
@@ -9941,6 +10775,11 @@ public final <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTi
      * <p>
      * <img width="640" height="400" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timeout6.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.</dd>
      * </dl>
@@ -9982,6 +10821,11 @@ public final <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTi
      * <p>
      * Note: The arrival of the first source item is never timed out.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.</dd>
      * </dl>
@@ -10010,6 +10854,11 @@ public final <V> Observable<T> timeout(Func1<? super T, ? extends Observable<V>>
      * <p>
      * Note: The arrival of the first source item is never timed out.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.</dd>
      * </dl>
@@ -10037,6 +10886,9 @@ public final <V> Observable<T> timeout(Func1<? super T, ? extends Observable<V>>
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timeout.1.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -10060,6 +10912,11 @@ public final Observable<T> timeout(long timeout, TimeUnit timeUnit) {
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timeout.2.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -10084,6 +10941,11 @@ public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<?
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timeout.2s.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well. 
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -10112,6 +10974,9 @@ public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<?
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timeout.1s.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -10136,6 +11001,9 @@ public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Scheduler sc
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timestamp.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code timestamp} operates by default on the {@code immediate} {@link Scheduler}.</dd>
      * </dl>
@@ -10153,6 +11021,9 @@ public final Observable<Timestamped<T>> timestamp() {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timestamp.s.png" alt="">
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -10170,6 +11041,9 @@ public final Observable<Timestamped<T>> timestamp(Scheduler scheduler) {
     /**
      * Converts an Observable into a {@link BlockingObservable} (an Observable with blocking operators).
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toBlocking} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10196,8 +11070,9 @@ public final BlockingObservable<T> toBlocking() {
      * Be careful not to use this operator on Observables that emit infinite or very large numbers of items, as
      * you do not have the option to unsubscribe.
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>The operator buffers everything from its upstream but it only emits the aggregated list when the downstream requests at least one item.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toList} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10218,8 +11093,9 @@ public final Observable<List<T>> toList() {
      * <p>
      * If more than one source item maps to the same key, the HashMap will contain the latest of those items.
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as by intent it is requesting and buffering everything.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10244,8 +11120,9 @@ public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySe
      * If more than one source item maps to the same key, the HashMap will contain a single entry that
      * corresponds to the latest of those items.
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as by intent it is requesting and buffering everything.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10270,8 +11147,9 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/toMap.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as by intent it is requesting and buffering everything.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10298,7 +11176,7 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/toMultiMap.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as by intent it is requesting and buffering everything.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
@@ -10322,8 +11200,9 @@ public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ?
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/toMultiMap.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as by intent it is requesting and buffering everything.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10349,8 +11228,9 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/toMultiMap.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as by intent it is requesting and buffering everything.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10378,8 +11258,9 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/toMultiMap.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as by intent it is requesting and buffering everything.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10409,8 +11290,9 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/toSortedList.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>The operator buffers everything from its upstream but it only emits the sorted list when the downstream requests at least one item.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toSortedList} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10432,8 +11314,9 @@ public final Observable<List<T>> toSortedList() {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/toSortedList.f.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>The operator buffers everything from its upstream but it only emits the sorted list when the downstream requests at least one item.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toSortedList} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10456,8 +11339,9 @@ public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Intege
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/toSortedList.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>The operator buffers everything from its upstream but it only emits the sorted list when the downstream requests at least one item.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toSortedList} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10483,8 +11367,9 @@ public final Observable<List<T>> toSortedList(int initialCapacity) {
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/toSortedList.f.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>The operator buffers everything from its upstream but it only emits the sorted list when the downstream requests at least one item.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toSortedList} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10508,6 +11393,9 @@ public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Intege
      * Modifies the source Observable so that subscribers will unsubscribe from it on a specified
      * {@link Scheduler}.
      * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
+     *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -10566,8 +11454,8 @@ public final <U, R> Observable<R> withLatestFrom(Observable<? extends U> other,
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
      *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
@@ -10598,8 +11486,8 @@ public final <T1, T2, R> Observable<R> withLatestFrom(Observable<T1> o1, Observa
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
      *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
@@ -10636,8 +11524,8 @@ public final <T1, T2, T3, R> Observable<R> withLatestFrom(
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
      *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
@@ -10675,8 +11563,8 @@ public final <T1, T2, T3, T4, R> Observable<R> withLatestFrom(
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
      *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
@@ -10718,8 +11606,8 @@ public final <T1, T2, T3, T4, T5, R> Observable<R> withLatestFrom(
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
      *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
@@ -10763,8 +11651,8 @@ public final <T1, T2, T3, T4, T5, T6, R> Observable<R> withLatestFrom(
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
      *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
@@ -10811,8 +11699,8 @@ public final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> withLatestFrom(
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
      *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
@@ -10861,8 +11749,8 @@ public final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> withLatestFrom(
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
      *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
@@ -10890,8 +11778,8 @@ public final <R> Observable<R> withLatestFrom(Observable<?>[] others, FuncN<R> c
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
      * 
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator is a pass-through for backpressure behavior between this {@code Observable}
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
      *  and the downstream Subscriber. The other {@code Observable}s are consumed in an unbounded manner.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
@@ -10916,9 +11804,12 @@ public final <R> Observable<R> withLatestFrom(Iterable<Observable<?>> others, Fu
      * <p>
      * <img width="640" height="460" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window1.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses the {@code closingSelector} to control data
-     *      flow.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
+     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  the {@code closingSelector} to control the creation of windows. The returned inner {@code Observable}s honor
+     *  backpressure but have an unbounded inner buffer that <em>may</em> lead to {@code OutOfMemoryError}
+     *  if left unconsumed.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -10926,7 +11817,7 @@ public final <R> Observable<R> withLatestFrom(Iterable<Observable<?>> others, Fu
      * @param <TClosing> the element type of the boundary Observable
      * @param closingSelector
      *            a {@link Func0} that returns an {@code Observable} that governs the boundary between windows.
-     *            When this {@code Observable} emits an item, {@code window} emits the current window and begins
+     *            When the source {@code Observable} emits an item, {@code window} emits the current window and begins
      *            a new one.
      * @return an Observable that emits connected, non-overlapping windows of items from the source Observable
      *         whenever {@code closingSelector} emits an item
@@ -10944,7 +11835,7 @@ public final <TClosing> Observable<Observable<T>> window(Func0<? extends Observa
      * <p>
      * <img width="640" height="400" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window3.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure of its inner and outer subscribers, however, the inner Observable uses an
      *  unbounded buffer that may hold at most {@code count} elements.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -10970,7 +11861,7 @@ public final Observable<Observable<T>> window(int count) {
      * <p>
      * <img width="640" height="365" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window4.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure of its inner and outer subscribers, however, the inner Observable uses an
      *  unbounded buffer that may hold at most {@code count} elements.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -11006,8 +11897,12 @@ public final Observable<Observable<T>> window(int count, int skip) {
      * <p>
      * <img width="640" height="335" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window7.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
+     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  time to control the creation of windows. The returned inner {@code Observable}s honor
+     *  backpressure but have an unbounded inner buffer that <em>may</em> lead to {@code OutOfMemoryError}
+     *  if left unconsumed.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -11034,8 +11929,12 @@ public final Observable<Observable<T>> window(long timespan, long timeshift, Tim
      * <p>
      * <img width="640" height="335" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window7.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
+     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  time to control the creation of windows. The returned inner {@code Observable}s honor
+     *  backpressure but have an unbounded inner buffer that <em>may</em> lead to {@code OutOfMemoryError}
+     *  if left unconsumed.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -11065,8 +11964,11 @@ public final Observable<Observable<T>> window(long timespan, long timeshift, Tim
      * <p>
      * <img width="640" height="335" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window7.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
+     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  time to control the creation of windows. The returned inner {@code Observable}s honor
+     *  backpressure and may hold up to {@code count} elements at most.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -11096,8 +11998,11 @@ public final Observable<Observable<T>> window(long timespan, long timeshift, Tim
      * <p>
      * <img width="640" height="375" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window5.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
+     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  time to control the creation of windows. The returned inner {@code Observable}s honor
+     *  backpressure and may hold up to {@code count} elements at most.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -11124,8 +12029,11 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit) {
      * <p>
      * <img width="640" height="370" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window6.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
+     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  time to control the creation of windows. The returned inner {@code Observable}s honor
+     *  backpressure and may hold up to {@code count} elements at most.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
@@ -11155,8 +12063,11 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int
      * <p>
      * <img width="640" height="370" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window6.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
+     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  time to control the creation of windows. The returned inner {@code Observable}s honor
+     *  backpressure and may hold up to {@code count} elements at most.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -11187,8 +12098,12 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int
      * <p>
      * <img width="640" height="375" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window5.s.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
-     *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
+     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  time to control the creation of windows. The returned inner {@code Observable}s honor
+     *  backpressure but have an unbounded inner buffer that <em>may</em> lead to {@code OutOfMemoryError}
+     *  if left unconsumed.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -11216,7 +12131,7 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit, Sche
      * <p>
      * <img width="640" height="550" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window2.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>The outer Observable of this operator doesn't support backpressure because the emission of new
      *  inner Observables are controlled by the {@code windowOpenings} Observable. 
      *  The inner Observables honor backpressure and buffer everything until the associated closing
@@ -11247,7 +12162,7 @@ public final <TOpening, TClosing> Observable<Observable<T>> window(Observable<?
      * <p>
      * <img width="640" height="475" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window8.png" alt="">
      * <dl>
-     *  <dt><b>Backpressure Support:</b></dt>
+     *  <dt><b>Backpressure:</b></dt>
      *  <dd>The outer Observable of this operator does not support backpressure as it uses a {@code boundary} Observable to control data
      *      flow. The inner Observables honor backpressure and buffer everything until the boundary signals the next element.</dd>
      *  <dt><b>Scheduler:</b></dt>

From 978825eafa7e99c4817640c47161dd83d1162d91 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 8 Jul 2016 09:05:40 +0200
Subject: [PATCH 096/263] 1.x: optimize collect, reduce and takeLast(1) (#4176)

* 1.x: optimize collect, reduce and takeLast(1)

* Fix regression in last and reduce

* Forgot that reduce() has to signal error if empty

* Update header year.
---
 src/main/java/rx/Observable.java              |  10 +-
 .../operators/DeferredScalarSubscriber.java   | 177 ++++++++
 .../operators/OnSubscribeCollect.java         |  76 ++++
 .../internal/operators/OnSubscribeReduce.java | 111 +++++
 .../operators/OnSubscribeReduceSeed.java      |  66 +++
 .../operators/OnSubscribeTakeLastOne.java     |  61 +++
 .../operators/OperatorTakeLastOne.java        | 192 ---------
 src/perf/java/rx/DeferredScalarPerf.java      |   6 +-
 .../rx/operators/OperatorTakeLastOnePerf.java |  11 +-
 .../DeferredScalarSubscriberTest.java         | 405 ++++++++++++++++++
 10 files changed, 907 insertions(+), 208 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/DeferredScalarSubscriber.java
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeCollect.java
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeReduce.java
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeReduceSeed.java
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeTakeLastOne.java
 delete mode 100644 src/main/java/rx/internal/operators/OperatorTakeLastOne.java
 create mode 100644 src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index a949467c6d..98b47ec796 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -4737,15 +4737,13 @@ public final <R> Observable<R> cast(final Class<R> klass) {
      * @see <a href="http://reactivex.io/documentation/operators/reduce.html">ReactiveX operators documentation: Reduce</a>
      */
     public final <R> Observable<R> collect(Func0<R> stateFactory, final Action2<R, ? super T> collector) {
-        Func2<R, T, R> accumulator = InternalObservableUtils.createCollectorCaller(collector);
-        
         /*
          * Discussion and confirmation of implementation at
          * https://github.com/ReactiveX/RxJava/issues/423#issuecomment-27642532
          * 
          * It should use last() not takeLast(1) since it needs to emit an error if the sequence is empty.
          */
-        return lift(new OperatorScan<R, T>(stateFactory, accumulator)).last();
+        return create(new OnSubscribeCollect<T, R>(this, stateFactory, collector));
     }
 
     /**
@@ -7899,7 +7897,7 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
          * 
          * It should use last() not takeLast(1) since it needs to emit an error if the sequence is empty.
          */
-        return scan(accumulator).last();
+        return create(new OnSubscribeReduce<T>(this, accumulator));
     }
 
     /**
@@ -7947,7 +7945,7 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
      * @see <a href="http://en.wikipedia.org/wiki/Fold_(higher-order_function)">Wikipedia: Fold (higher-order function)</a>
      */
     public final <R> Observable<R> reduce(R initialValue, Func2<R, ? super T, R> accumulator) {
-        return scan(initialValue, accumulator).takeLast(1);
+        return create(new OnSubscribeReduceSeed<T, R>(this, initialValue, accumulator));
     }
     
     /**
@@ -10154,7 +10152,7 @@ public final Observable<T> takeLast(final int count) {
         if (count == 0) {
             return ignoreElements();
         } else if (count == 1) {
-            return lift(OperatorTakeLastOne.<T>instance());
+            return create(new OnSubscribeTakeLastOne<T>(this));
         } else {
             return lift(new OperatorTakeLast<T>(count));
         }
diff --git a/src/main/java/rx/internal/operators/DeferredScalarSubscriber.java b/src/main/java/rx/internal/operators/DeferredScalarSubscriber.java
new file mode 100644
index 0000000000..f86dce6f4c
--- /dev/null
+++ b/src/main/java/rx/internal/operators/DeferredScalarSubscriber.java
@@ -0,0 +1,177 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import rx.*;
+
+/**
+ * Base class for Subscribers that consume the entire upstream and signal
+ * zero or one element (or an error) in a backpressure honoring fashion.
+ * <p>
+ * Store any temporary value in {@link #value} and indicate there is
+ * a value available when completing by setting {@link #hasValue}.
+ * <p.
+ * Use {@link #subscribeTo(Observable)} to properly setup the link between this and the downstream
+ * subscriber.
+ * 
+ * @param <T> the source value type
+ * @param <R> the result value type
+ */
+public abstract class DeferredScalarSubscriber<T, R> extends Subscriber<T> {
+
+    /** The downstream subscriber. */
+    protected final Subscriber<? super R> actual;
+    
+    /** Indicates there is a value available in value. */
+    protected boolean hasValue;
+    
+    /** The holder of the single value. */
+    protected R value;
+    
+    /** The state, see the constants below. */
+    final AtomicInteger state;
+    
+    /** Initial state. */
+    static final int NO_REQUEST_NO_VALUE = 0;
+    /** Request came first. */
+    static final int HAS_REQUEST_NO_VALUE = 1;
+    /** Value came first. */
+    static final int NO_REQUEST_HAS_VALUE = 2;
+    /** Value will be emitted. */
+    static final int HAS_REQUEST_HAS_VALUE = 3;
+    
+    public DeferredScalarSubscriber(Subscriber<? super R> actual) {
+        this.actual = actual;
+        this.state = new AtomicInteger();
+    }
+    
+    @Override
+    public void onError(Throwable ex) {
+        value = null;
+        actual.onError(ex);
+    }
+    
+    @Override
+    public void onCompleted() {
+        if (hasValue) {
+            complete(value);
+        } else {
+            complete();
+        }
+    }
+    
+    /**
+     * Signals onCompleted() to the downstream subscriber.
+     */
+    protected final void complete() {
+        actual.onCompleted();
+    }
+    
+    /**
+     * Atomically switches to the terminal state and emits the value if
+     * there is a request for it or stores it for retrieval by {@link #downstreamRequest(long)}.
+     * @param value the value to complete with
+     */
+    protected final void complete(R value) {
+        Subscriber<? super R> a = actual;
+        for (;;) {
+            int s = state.get();
+            
+            if (s == NO_REQUEST_HAS_VALUE || s == HAS_REQUEST_HAS_VALUE || a.isUnsubscribed()) {
+                return;
+            }
+            if (s == HAS_REQUEST_NO_VALUE) {
+                a.onNext(value);
+                if (!a.isUnsubscribed()) {
+                    a.onCompleted();
+                }
+                state.lazySet(HAS_REQUEST_HAS_VALUE);
+                return;
+            }
+            this.value = value;
+            if (state.compareAndSet(NO_REQUEST_NO_VALUE, NO_REQUEST_HAS_VALUE)) {
+                return;
+            }
+        }
+    }
+    
+    final void downstreamRequest(long n) {
+        if (n < 0L) {
+            throw new IllegalArgumentException("n >= 0 required but it was " + n);
+        }
+        if (n != 0L) {
+            Subscriber<? super R> a = actual;
+            for (;;) {
+                int s = state.get();
+                if (s == HAS_REQUEST_NO_VALUE || s == HAS_REQUEST_HAS_VALUE || a.isUnsubscribed()) {
+                    return;
+                }
+                if (s == NO_REQUEST_HAS_VALUE) {
+                    if (state.compareAndSet(NO_REQUEST_HAS_VALUE, HAS_REQUEST_HAS_VALUE)) {
+                        a.onNext(value);
+                        if (!a.isUnsubscribed()) {
+                            a.onCompleted();
+                        }
+                    }
+                    return;
+                }
+                if (state.compareAndSet(NO_REQUEST_NO_VALUE, HAS_REQUEST_NO_VALUE)) {
+                    return;
+                }
+            }
+        }
+    }
+    
+    @Override
+    public final void setProducer(Producer p) {
+        p.request(Long.MAX_VALUE);
+    }
+    
+    /**
+     * Links up with the downstream Subscriber (cancellation, backpressure) and
+     * subscribes to the source Observable.
+     * @param source the source Observable
+     */
+    public final void subscribeTo(Observable<? extends T> source) {
+        setupDownstream();
+        source.unsafeSubscribe(this);
+    }
+    
+    /* test */ final void setupDownstream() {
+        Subscriber<? super R> a = actual;
+        a.add(this);
+        a.setProducer(new InnerProducer(this));
+    }
+    
+    /**
+     * Redirects the downstream request amount bach to the DeferredScalarSubscriber.
+     */
+    static final class InnerProducer implements Producer {
+        final DeferredScalarSubscriber<?, ?> parent;
+
+        public InnerProducer(DeferredScalarSubscriber<?, ?> parent) {
+            this.parent = parent;
+        }
+        
+        @Override
+        public void request(long n) {
+            parent.downstreamRequest(n);
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeCollect.java b/src/main/java/rx/internal/operators/OnSubscribeCollect.java
new file mode 100644
index 0000000000..9e28ece0d7
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeCollect.java
@@ -0,0 +1,76 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.exceptions.Exceptions;
+import rx.functions.*;
+
+public final class OnSubscribeCollect<T, R> implements OnSubscribe<R> {
+
+    final Observable<T> source;
+    
+    final Func0<R> collectionFactory;
+    
+    final Action2<R, ? super T> collector;
+
+    public OnSubscribeCollect(Observable<T> source, Func0<R> collectionFactory, Action2<R, ? super T> collector) {
+        this.source = source;
+        this.collectionFactory = collectionFactory;
+        this.collector = collector;
+    }
+    
+    @Override
+    public void call(Subscriber<? super R> t) {
+        R initialValue;
+        
+        try {
+            initialValue = collectionFactory.call();
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            t.onError(ex);
+            return;
+        }
+        
+        new CollectSubscriber<T, R>(t, initialValue, collector).subscribeTo(source);
+    }
+    
+    static final class CollectSubscriber<T, R> extends DeferredScalarSubscriber<T, R> {
+
+        final Action2<R, ? super T> collector;
+
+        public CollectSubscriber(Subscriber<? super R> actual, R initialValue, Action2<R, ? super T> collector) {
+            super(actual);
+            this.value = initialValue;
+            this.hasValue = true;
+            this.collector = collector;
+        }
+
+        @Override
+        public void onNext(T t) {
+            try {
+                collector.call(value, t);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                actual.onError(ex);
+            }
+        }
+        
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeReduce.java b/src/main/java/rx/internal/operators/OnSubscribeReduce.java
new file mode 100644
index 0000000000..ef910e88ac
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeReduce.java
@@ -0,0 +1,111 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.NoSuchElementException;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.exceptions.Exceptions;
+import rx.functions.Func2;
+
+public final class OnSubscribeReduce<T> implements OnSubscribe<T> {
+
+    final Observable<T> source;
+    
+    final Func2<T, T, T> reducer;
+
+    public OnSubscribeReduce(Observable<T> source, Func2<T, T, T> reducer) {
+        this.source = source;
+        this.reducer = reducer;
+    }
+    
+    @Override
+    public void call(Subscriber<? super T> t) {
+        final ReduceSubscriber<T> parent = new ReduceSubscriber<T>(t, reducer);
+        t.add(parent);
+        t.setProducer(new Producer() {
+            @Override
+            public void request(long n) {
+                parent.downstreamRequest(n);
+            }
+        });
+        source.unsafeSubscribe(parent);
+    }
+    
+    static final class ReduceSubscriber<T> extends Subscriber<T> {
+
+        final Subscriber<? super T> actual;
+        
+        final Func2<T, T, T> reducer;
+
+        T value;
+        
+        static final Object EMPTY = new Object();
+        
+        @SuppressWarnings("unchecked")
+        public ReduceSubscriber(Subscriber<? super T> actual, Func2<T, T, T> reducer) {
+            this.actual = actual;
+            this.reducer = reducer;
+            this.value = (T)EMPTY;
+            this.request(0);
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void onNext(T t) {
+            Object o = value;
+            if (o == EMPTY) {
+                value = t;
+            } else {
+                try {
+                    value = reducer.call((T)o, t);
+                } catch (Throwable ex) {
+                    Exceptions.throwIfFatal(ex);
+                    unsubscribe();
+                    actual.onError(ex);
+                }
+            }
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            actual.onError(e);
+        }
+        
+        @SuppressWarnings("unchecked")
+        @Override
+        public void onCompleted() {
+            Object o = value;
+            if (o != EMPTY) {
+                actual.onNext((T)o);
+                actual.onCompleted();
+            } else {
+                actual.onError(new NoSuchElementException());
+            }
+        }
+        
+        void downstreamRequest(long n) {
+            if (n < 0L) {
+                throw new IllegalArgumentException("n >= 0 required but it was " + n);
+            }
+            if (n != 0L) {
+                request(Long.MAX_VALUE);
+            }
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeReduceSeed.java b/src/main/java/rx/internal/operators/OnSubscribeReduceSeed.java
new file mode 100644
index 0000000000..12c023238a
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeReduceSeed.java
@@ -0,0 +1,66 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.exceptions.Exceptions;
+import rx.functions.Func2;
+
+public final class OnSubscribeReduceSeed<T, R> implements OnSubscribe<R> {
+
+    final Observable<T> source;
+    
+    final R initialValue;
+    
+    final Func2<R, ? super T, R> reducer;
+
+    public OnSubscribeReduceSeed(Observable<T> source, R initialValue, Func2<R, ? super T, R> reducer) {
+        this.source = source;
+        this.initialValue = initialValue;
+        this.reducer = reducer;
+    }
+    
+    @Override
+    public void call(Subscriber<? super R> t) {
+        new ReduceSeedSubscriber<T, R>(t, initialValue, reducer).subscribeTo(source);
+    }
+    
+    static final class ReduceSeedSubscriber<T, R> extends DeferredScalarSubscriber<T, R> {
+
+        final Func2<R, ? super T, R> reducer;
+
+        public ReduceSeedSubscriber(Subscriber<? super R> actual, R initialValue, Func2<R, ? super T, R> reducer) {
+            super(actual);
+            this.value = initialValue;
+            this.hasValue = true;
+            this.reducer = reducer;
+        }
+
+        @Override
+        public void onNext(T t) {
+            try {
+                value = reducer.call(value, t);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                actual.onError(ex);
+            }
+        }
+        
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeTakeLastOne.java b/src/main/java/rx/internal/operators/OnSubscribeTakeLastOne.java
new file mode 100644
index 0000000000..a07873d161
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeTakeLastOne.java
@@ -0,0 +1,61 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+
+public final class OnSubscribeTakeLastOne<T> implements OnSubscribe<T> {
+
+    final Observable<T> source;
+
+    public OnSubscribeTakeLastOne(Observable<T> source) {
+        this.source = source;
+    }
+    
+    @Override
+    public void call(Subscriber<? super T> t) {
+        new TakeLastOneSubscriber<T>(t).subscribeTo(source);
+    }
+    
+    static final class TakeLastOneSubscriber<T> extends DeferredScalarSubscriber<T, T> {
+
+        static final Object EMPTY = new Object();
+        
+        @SuppressWarnings("unchecked")
+        public TakeLastOneSubscriber(Subscriber<? super T> actual) {
+            super(actual);
+            this.value = (T)EMPTY;
+        }
+
+        @Override
+        public void onNext(T t) {
+            value = t;
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void onCompleted() {
+            Object o = value;
+            if (o == EMPTY) {
+                complete();
+            } else {
+                complete((T)o);
+            }
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OperatorTakeLastOne.java b/src/main/java/rx/internal/operators/OperatorTakeLastOne.java
deleted file mode 100644
index 9625608d02..0000000000
--- a/src/main/java/rx/internal/operators/OperatorTakeLastOne.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/**
- * Copyright 2016 Netflix, Inc.
- *
- * 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 rx.internal.operators;
-
-import java.util.concurrent.atomic.AtomicInteger;
-
-import rx.*;
-import rx.Observable.Operator;
-import rx.exceptions.Exceptions;
-
-public class OperatorTakeLastOne<T> implements Operator<T, T> {
-
-    static final class Holder {
-        static final OperatorTakeLastOne<Object> INSTANCE = new OperatorTakeLastOne<Object>();
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T> OperatorTakeLastOne<T> instance() {
-        return (OperatorTakeLastOne<T>) Holder.INSTANCE;
-    }
-
-    OperatorTakeLastOne() {
-        // singleton
-    }
-
-    @Override
-    public Subscriber<? super T> call(Subscriber<? super T> child) {
-        final ParentSubscriber<T> parent = new ParentSubscriber<T>(child);
-        child.setProducer(new Producer() {
-
-            @Override
-            public void request(long n) {
-                parent.requestMore(n);
-            }
-        });
-        child.add(parent);
-        return parent;
-    }
-
-    static final class ParentSubscriber<T> extends Subscriber<T> {
-
-        private final static int NOT_REQUESTED_NOT_COMPLETED = 0;
-        private final static int NOT_REQUESTED_COMPLETED = 1;
-        private final static int REQUESTED_NOT_COMPLETED = 2;
-        private final static int REQUESTED_COMPLETED = 3;
-
-        /*
-         * These are the expected state transitions:
-         * 
-         * NOT_REQUESTED_NOT_COMPLETED   -->   REQUESTED_NOT_COMPLETED 
-         *            |                             | 
-         *            V                             V
-         * NOT_REQUESTED_COMPLETED       -->   REQUESTED_COMPLETED
-         * 
-         * Once at REQUESTED_COMPLETED we emit the last value if one exists
-         */
-
-        // Used as the initial value of last
-        private static final Object ABSENT = new Object();
-
-        // the downstream subscriber
-        private final Subscriber<? super T> child;
-
-        @SuppressWarnings("unchecked")
-        // we can get away with this cast at runtime because of type erasure
-        private T last = (T) ABSENT;
-
-        // holds the current state of the stream so that we can make atomic
-        // updates to it
-        private final AtomicInteger state = new AtomicInteger(NOT_REQUESTED_NOT_COMPLETED);
-
-        ParentSubscriber(Subscriber<? super T> child) {
-            this.child = child;
-        }
-        
-        void requestMore(long n) {
-            if (n > 0) {
-                // CAS loop to atomically change state given that onCompleted()
-                // or another requestMore() may be acting concurrently
-                while (true) {
-                    // read the value of state and then try state transitions
-                    // only if the value of state does not change in the
-                    // meantime (in another requestMore() or onCompleted()). If
-                    // the value has changed and we expect to do a transition
-                    // still then we loop and try again.
-                    final int s = state.get();
-                    if (s == NOT_REQUESTED_NOT_COMPLETED) {
-                        if (state.compareAndSet(NOT_REQUESTED_NOT_COMPLETED,
-                                REQUESTED_NOT_COMPLETED)) {
-                            return;
-                        }
-                    } else if (s == NOT_REQUESTED_COMPLETED) {
-                        if (state.compareAndSet(NOT_REQUESTED_COMPLETED, REQUESTED_COMPLETED)) {
-                            emit();
-                            return;
-                        }
-                    } else {
-                        // already requested so we exit
-                        return;
-                    }
-                }
-            }
-        }
-
-        @Override
-        public void onCompleted() {
-            //shortcut if an empty stream
-            if (last == ABSENT) {
-                child.onCompleted();
-                return;
-            }
-            // CAS loop to atomically change state given that requestMore()
-            // may be acting concurrently
-            while (true) {
-                // read the value of state and then try state transitions
-                // only if the value of state does not change in the meantime
-                // (in another requestMore()). If the value has changed and
-                // we expect to do a transition still then we loop and try
-                // again.
-                final int s = state.get();
-                if (s == NOT_REQUESTED_NOT_COMPLETED) {
-                    if (state.compareAndSet(NOT_REQUESTED_NOT_COMPLETED, NOT_REQUESTED_COMPLETED)) {
-                        return;
-                    }
-                } else if (s == REQUESTED_NOT_COMPLETED) {
-                    if (state.compareAndSet(REQUESTED_NOT_COMPLETED, REQUESTED_COMPLETED)) {
-                        emit();
-                        return;
-                    }
-                } else {
-                    // already completed so we exit
-                    return;
-                }
-            }
-        }
-
-        /**
-         * If not unsubscribed then emits last value and completed to the child
-         * subscriber.
-         */
-        private void emit() {
-            if (isUnsubscribed()) {
-                // release for gc
-                last = null;
-                return;
-            }
-            // Note that last is safely published despite not being volatile
-            // because a CAS update must have happened in the current thread just before
-            // emit() was called
-            T t = last;
-            // release for gc
-            last = null;
-            if (t != ABSENT) {
-                try {
-                    child.onNext(t);
-                } catch (Throwable e) {
-                    Exceptions.throwOrReport(e, child);
-                    return;
-                }
-            }
-            if (!isUnsubscribed()) {
-                child.onCompleted();
-            }
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            child.onError(e);
-        }
-
-        @Override
-        public void onNext(T t) {
-            last = t;
-        }
-
-    }
-
-}
diff --git a/src/perf/java/rx/DeferredScalarPerf.java b/src/perf/java/rx/DeferredScalarPerf.java
index fb96df3bdf..cd0f73d465 100644
--- a/src/perf/java/rx/DeferredScalarPerf.java
+++ b/src/perf/java/rx/DeferredScalarPerf.java
@@ -83,17 +83,17 @@ public void call(int[] a, Integer b) {
         } );
     }
     
-//    @Benchmark
+    @Benchmark
     public void reduce(Blackhole bh) {
         reduce.subscribe(new LatchedObserver<Integer>(bh));
     }
 
-//    @Benchmark
+    @Benchmark
     public void reduceSeed(Blackhole bh) {
         reduceSeed.subscribe(new LatchedObserver<Integer>(bh));
     }
 
-//    @Benchmark
+    @Benchmark
     public void last(Blackhole bh) {
         last.subscribe(new LatchedObserver<Integer>(bh));
     }
diff --git a/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java b/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
index c04c73fa9b..dd41da53cc 100644
--- a/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
+++ b/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
@@ -16,13 +16,10 @@
 
 package rx.operators;
 
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.*;
 
-import rx.internal.operators.OperatorTakeLast;
-import rx.internal.operators.OperatorTakeLastOne;
+import rx.Observable;
+import rx.internal.operators.*;
 import rx.jmh.InputWithIncrementingInteger;
 
 public class OperatorTakeLastOnePerf {
@@ -49,7 +46,7 @@ public void takeLastOneUsingTakeLast(Input input) {
     
     @Benchmark
     public void takeLastOneUsingTakeLastOne(Input input) {
-       input.observable.lift(OperatorTakeLastOne.<Integer>instance()).subscribe(input.observer);
+       Observable.create(new OnSubscribeTakeLastOne<Integer>(input.observable)).subscribe(input.observer);
     }
     
 }
diff --git a/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java b/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
new file mode 100644
index 0000000000..f1aab5c286
--- /dev/null
+++ b/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
@@ -0,0 +1,405 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import static org.junit.Assert.*;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.Test;
+
+import rx.*;
+import rx.Scheduler.Worker;
+import rx.exceptions.TestException;
+import rx.functions.Action0;
+import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
+import rx.subjects.PublishSubject;
+
+public class DeferredScalarSubscriberTest {
+
+    @Test
+    public void completeFirst() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0L);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.setupDownstream();
+        
+        ds.onNext(1);
+
+        ts.assertNoValues();
+
+        ds.onCompleted();
+        
+        ts.assertNoValues();
+        
+        ts.requestMore(1);
+        
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void requestFirst() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(1);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.setupDownstream();
+        
+        ds.onNext(1);
+
+        ts.assertNoValues();
+        
+        ds.onCompleted();
+        
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void empty() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0L);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.setupDownstream();
+        
+        ts.assertNoValues();
+
+        ds.onCompleted();
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void error() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0L);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.setupDownstream();
+        
+        ts.assertNoValues();
+
+        ds.onError(new TestException());
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void unsubscribeComposes() {
+        PublishSubject<Integer> ps = PublishSubject.create();
+        TestSubscriber<Integer> ts = TestSubscriber.create(0L);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        
+        ds.subscribeTo(ps);
+        
+        assertTrue("No subscribers?", ps.hasObservers());
+        
+        ts.unsubscribe();
+        
+        ds.onNext(1);
+        ds.onCompleted();
+        
+        ts.requestMore(1);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+
+        assertFalse("Subscribers?", ps.hasObservers());
+        assertTrue("Deferred not unsubscribed?", ds.isUnsubscribed());
+    }
+    
+    @Test
+    public void emptySource() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0L);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.subscribeTo(Observable.just(1).ignoreElements()); // we need a producer from upstream
+        
+        ts.assertNoValues();
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void justSource() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0L);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.subscribeTo(Observable.just(1));
+        
+        ts.assertNoValues();
+
+        ts.requestMore(1);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void rangeSource() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.subscribeTo(Observable.range(1, 10));
+        
+        ts.assertNoValues();
+
+        ts.requestMore(1);
+        
+        ts.assertValue(10);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void completeAfterNext() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                unsubscribe();
+            }
+        };
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.setupDownstream();
+        ds.onNext(1);
+        
+        ts.assertNoValues();
+
+        ds.onCompleted();
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void completeAfterNextViaRequest() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L) {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                unsubscribe();
+            }
+        };
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.setupDownstream();
+        ds.onNext(1);
+        ds.onCompleted();
+        
+        ts.assertNoValues();
+
+        ts.requestMore(1);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void doubleComplete() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.setupDownstream();
+        
+        ds.onNext(1);
+        
+        ts.requestMore(1);
+        
+        ds.onCompleted();
+        ds.onCompleted();
+        
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void doubleComplete2() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.setupDownstream();
+        
+        ds.onNext(1);
+        
+        ds.onCompleted();
+        ds.onCompleted();
+        
+        ts.requestMore(1);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void doubleRequest() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.setupDownstream();
+        
+        ds.onNext(1);
+        
+        ts.requestMore(1);
+        ts.requestMore(1);
+        
+        ds.onCompleted();
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void negativeRequest() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.setupDownstream();
+
+        try {
+            ds.downstreamRequest(-99);
+            fail("Failed to throw IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("n >= 0 required but it was -99", ex.getMessage());
+        }
+    }
+
+    @Test
+    public void callsAfterUnsubscribe() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+        ds.setupDownstream();
+        
+        ts.unsubscribe();
+        
+        ds.downstreamRequest(1);
+        ds.onNext(1);
+        ds.onCompleted();
+        ds.onCompleted();
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+    @Test
+    public void emissionRequestRace() {
+        Worker w = Schedulers.computation().createWorker();
+        try {
+            for (int i = 0; i < 10000; i++) {
+    
+                final TestSubscriber<Integer> ts = TestSubscriber.create(0L);
+                TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+                ds.setupDownstream();
+                ds.onNext(1);
+    
+                final AtomicInteger ready = new AtomicInteger(2);
+                
+                w.schedule(new Action0() {
+                    @Override
+                    public void call() {
+                        ready.decrementAndGet();
+                        while (ready.get() != 0) ;
+
+                        ts.requestMore(1);
+                    }
+                });
+                
+                ready.decrementAndGet();
+                while (ready.get() != 0) ;
+                
+                ds.onCompleted();
+                
+                ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+                ts.assertValues(1);
+                ts.assertNoErrors();
+                ts.assertCompleted();
+    
+            }
+        } finally {
+            w.unsubscribe();
+        }
+    }
+    
+    @Test
+    public void emissionRequestRace2() {
+        Worker w = Schedulers.computation().createWorker();
+        Worker w2 = Schedulers.computation().createWorker();
+        try {
+            for (int i = 0; i < 10000; i++) {
+    
+                final TestSubscriber<Integer> ts = TestSubscriber.create(0L);
+                TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
+                ds.setupDownstream();
+                ds.onNext(1);
+    
+                final AtomicInteger ready = new AtomicInteger(3);
+                
+                w.schedule(new Action0() {
+                    @Override
+                    public void call() {
+                        ready.decrementAndGet();
+                        while (ready.get() != 0) ;
+
+                        ts.requestMore(1);
+                    }
+                });
+
+                w2.schedule(new Action0() {
+                    @Override
+                    public void call() {
+                        ready.decrementAndGet();
+                        while (ready.get() != 0) ;
+
+                        ts.requestMore(1);
+                    }
+                });
+
+                ready.decrementAndGet();
+                while (ready.get() != 0) ;
+                
+                ds.onCompleted();
+                
+                ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+                ts.assertValues(1);
+                ts.assertNoErrors();
+                ts.assertCompleted();
+    
+            }
+        } finally {
+            w.unsubscribe();
+            w2.unsubscribe();
+        }
+    }
+    
+    static final class TestingDeferredScalarSubscriber extends DeferredScalarSubscriber<Integer, Integer> {
+
+        public TestingDeferredScalarSubscriber(Subscriber<? super Integer> actual) {
+            super(actual);
+        }
+
+        @Override
+        public void onNext(Integer t) {
+            value = t;
+            hasValue = true;
+        }
+    }
+}

From 97c4e537867efd4c9411c14bda0a40de76e83218 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 8 Jul 2016 22:43:43 +0200
Subject: [PATCH 097/263] 1.x: improve coverage of rx.Observable methods
 (#4178)

* 1.x: improve coverage of rx.Observable methods

* Added missing methods

* Update based on feedback
---
 src/main/java/rx/Notification.java            |  14 +-
 src/main/java/rx/Observable.java              |  21 +-
 .../operators/DeferredScalarSubscriber.java   |   2 +-
 .../internal/operators/OnSubscribeRedo.java   |   2 +-
 .../internal/operators/OperatorGroupBy.java   |   2 +-
 .../rx/internal/util/SynchronizedQueue.java   |   5 +-
 src/test/java/rx/NotificationTest.java        | 142 +++++---
 src/test/java/rx/ObservableTests.java         | 307 +++++++++++++++++-
 .../java/rx/ThrottleWithTimeoutTests.java     |  14 +
 .../java/rx/exceptions/TestException.java     |  10 -
 .../operators/OnSubscribeAmbTest.java         | 193 ++++++++++-
 .../OnSubscribeCombineLatestTest.java         |  19 ++
 .../OnSubscribeConcatDelayErrorTest.java      |  67 ++++
 ...OnSubscribeDelaySubscriptionOtherTest.java |   4 +
 .../OnSubscribeFlattenIterableTest.java       |  49 ++-
 .../operators/OnSubscribeFromArrayTest.java   |  14 +-
 .../operators/OnSubscribeRangeTest.java       |  29 +-
 .../operators/OnSubscribeTimerTest.java       |  41 +++
 .../OnSubscribeToObservableFutureTest.java    |  59 ++++
 .../operators/OperatorBufferTest.java         | 211 ++++++++++--
 .../operators/OperatorConcatTest.java         | 129 ++++++--
 .../operators/OperatorDebounceTest.java       |  13 +
 .../OperatorDoAfterTerminateTest.java         |   8 +
 .../operators/OperatorEagerConcatMapTest.java |  95 +++++-
 .../OperatorMergeDelayErrorTest.java          | 120 +++++++
 .../internal/operators/OperatorMergeTest.java | 127 +++++++-
 .../OperatorOnBackpressureBufferTest.java     |  10 +
 .../operators/OperatorRepeatTest.java         |  51 ++-
 .../operators/OperatorReplayTest.java         | 242 ++++++++++++--
 .../internal/operators/OperatorRetryTest.java |  41 ++-
 .../operators/OperatorSkipLastTest.java       |  46 ++-
 .../internal/operators/OperatorSkipTest.java  |  42 ++-
 .../operators/OperatorTakeLastTest.java       |  59 ++++
 .../operators/OperatorTakeLastTimedTest.java  |  42 ++-
 .../operators/OperatorTakeTimedTest.java      |  44 ++-
 .../operators/OperatorThrottleFirstTest.java  |  14 +
 .../operators/OperatorTimeIntervalTest.java   |  42 ++-
 .../operators/OperatorTimeoutTests.java       | 103 +++++-
 .../OperatorTimeoutWithSelectorTest.java      |  36 +-
 .../operators/OperatorTimestampTest.java      |  55 +++-
 .../OperatorToObservableSortedListTest.java   |  49 +++
 .../operators/OperatorWindowWithTimeTest.java |  37 +++
 .../internal/operators/OperatorZipTest.java   | 155 +++++++--
 .../rx/observables/AsyncOnSubscribeTest.java  |   2 +-
 .../java/rx/schedulers/SchedulerTests.java    |  10 +-
 45 files changed, 2488 insertions(+), 289 deletions(-)

diff --git a/src/main/java/rx/Notification.java b/src/main/java/rx/Notification.java
index f1cfdab4ef..9d50d09bb0 100644
--- a/src/main/java/rx/Notification.java
+++ b/src/main/java/rx/Notification.java
@@ -158,18 +158,12 @@ public boolean isOnNext() {
      * @param observer the target observer to call onXXX methods on based on the kind of this Notification instance
      */
     public void accept(Observer<? super T> observer) {
-        switch (kind) {
-        case OnNext:
+        if (kind == Kind.OnNext) {
             observer.onNext(getValue());
-            break;
-        case OnError:
-            observer.onError(getThrowable());
-            break;
-        case OnCompleted:
+        } else if (kind == Kind.OnCompleted) {
             observer.onCompleted();
-            break;
-        default:
-            throw new AssertionError("Uncovered case: " + kind);
+        } else {
+            observer.onError(getThrowable());
         }
     }
 
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 98b47ec796..7b462abd90 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -9781,6 +9781,9 @@ public final Subscription subscribe(final Observer<? super T> observer) {
         if (observer instanceof Subscriber) {
             return subscribe((Subscriber<? super T>)observer);
         }
+        if (observer == null) {
+            throw new NullPointerException("observer is null");
+        }
         return subscribe(new ObserverSubscriber<T>(observer));
     }
 
@@ -9822,7 +9825,7 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
                 Exceptions.throwIfFatal(e2);
                 // if this happens it means the onError itself failed (perhaps an invalid function implementation)
                 // so we are unable to propagate the error correctly and will just throw
-                RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
+                RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
                 // TODO could the hook be the cause of the error in the on error handling.
                 RxJavaHooks.onObservableError(r);
                 // TODO why aren't we throwing the hook's return value.
@@ -10699,14 +10702,15 @@ public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit, Sche
      *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
      *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
-     *  <dd>{@code timeInterval} operates by default on the {@code immediate} {@link Scheduler}.</dd>
+     *  <dd>{@code timeInterval} does not operate on any particular scheduler but uses the current time
+     *  from the {@code computation} {@link Scheduler}.</dd>
      * </dl>
      * 
      * @return an Observable that emits time interval information items
      * @see <a href="http://reactivex.io/documentation/operators/timeinterval.html">ReactiveX operators documentation: TimeInterval</a>
      */
     public final Observable<TimeInterval<T>> timeInterval() {
-        return timeInterval(Schedulers.immediate());
+        return timeInterval(Schedulers.computation());
     }
 
     /**
@@ -10719,7 +10723,8 @@ public final Observable<TimeInterval<T>> timeInterval() {
      *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
      *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
-     *  <dd>you specify which {@link Scheduler} this operator will use</dd>
+     *  <dd>The operator does not operate on any particular scheduler but uses the current time
+     *  from the specified {@link Scheduler}.</dd>
      * </dl>
      * 
      * @param scheduler
@@ -11003,14 +11008,15 @@ public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Scheduler sc
      *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
      *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
-     *  <dd>{@code timestamp} operates by default on the {@code immediate} {@link Scheduler}.</dd>
+     *  <dd>{@code timestamp} does not operate on any particular scheduler but uses the current time
+     *  from the {@code computation} {@link Scheduler}.</dd>
      * </dl>
      * 
      * @return an Observable that emits timestamped items from the source Observable
      * @see <a href="http://reactivex.io/documentation/operators/timestamp.html">ReactiveX operators documentation: Timestamp</a>
      */
     public final Observable<Timestamped<T>> timestamp() {
-        return timestamp(Schedulers.immediate());
+        return timestamp(Schedulers.computation());
     }
 
     /**
@@ -11023,7 +11029,8 @@ public final Observable<Timestamped<T>> timestamp() {
      *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
      *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
-     *  <dd>you specify which {@link Scheduler} this operator will use</dd>
+     *  <dd>The operator does not operate on any particular scheduler but uses the current time
+     *  from the specified {@link Scheduler}.</dd>
      * </dl>
      * 
      * @param scheduler
diff --git a/src/main/java/rx/internal/operators/DeferredScalarSubscriber.java b/src/main/java/rx/internal/operators/DeferredScalarSubscriber.java
index f86dce6f4c..2cdfccaed2 100644
--- a/src/main/java/rx/internal/operators/DeferredScalarSubscriber.java
+++ b/src/main/java/rx/internal/operators/DeferredScalarSubscriber.java
@@ -85,7 +85,7 @@ protected final void complete() {
     
     /**
      * Atomically switches to the terminal state and emits the value if
-     * there is a request for it or stores it for retrieval by {@link #downstreamRequest(long)}.
+     * there is a request for it or stores it for retrieval by {@code downstreamRequest(long)}.
      * @param value the value to complete with
      */
     protected final void complete(R value) {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeRedo.java b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
index f9cba08127..b258519fdf 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRedo.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
@@ -31,7 +31,7 @@
  * limitations under the License.
  */
 
-import static rx.Observable.create;
+import static rx.Observable.create; // NOPMD
 
 import java.util.concurrent.atomic.*;
 
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index 55e13fe8c7..61f1bef9b1 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -73,7 +73,7 @@ public OperatorGroupBy(Func1<? super T, ? extends K> keySelector, Func1<? super
     
     @Override
     public Subscriber<? super T> call(Subscriber<? super GroupedObservable<K, V>> child) {
-        final GroupBySubscriber<T, K, V> parent;
+        final GroupBySubscriber<T, K, V> parent; // NOPMD
         try {
             parent = new GroupBySubscriber<T, K, V>(child, keySelector, valueSelector, bufferSize, delayError, mapFactory);
         } catch (Throwable ex) {
diff --git a/src/main/java/rx/internal/util/SynchronizedQueue.java b/src/main/java/rx/internal/util/SynchronizedQueue.java
index 895bc3e26f..667e9d4083 100644
--- a/src/main/java/rx/internal/util/SynchronizedQueue.java
+++ b/src/main/java/rx/internal/util/SynchronizedQueue.java
@@ -115,10 +115,7 @@ public boolean equals(Object obj) {
             return false;
         }
         SynchronizedQueue<?> other = (SynchronizedQueue<?>) obj;
-        if (!list.equals(other.list)) {
-            return false;
-        }
-        return true;
+        return list.equals(other.list);
     }
 
     @Override
diff --git a/src/test/java/rx/NotificationTest.java b/src/test/java/rx/NotificationTest.java
index bd6e224ca9..b7997dc50d 100644
--- a/src/test/java/rx/NotificationTest.java
+++ b/src/test/java/rx/NotificationTest.java
@@ -18,6 +18,7 @@
 
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.*;
+import static org.junit.Assert.*;
 
 import java.util.*;
 
@@ -31,42 +32,42 @@ public class NotificationTest {
     public void testOnNextIntegerNotificationDoesNotEqualNullNotification(){
         final Notification<Integer> integerNotification = Notification.createOnNext(1);
         final Notification<Integer> nullNotification = Notification.createOnNext(null);
-        Assert.assertFalse(integerNotification.equals(nullNotification));
+        assertFalse(integerNotification.equals(nullNotification));
     }
 
     @Test
     public void testOnNextNullNotificationDoesNotEqualIntegerNotification(){
         final Notification<Integer> integerNotification = Notification.createOnNext(1);
         final Notification<Integer> nullNotification = Notification.createOnNext(null);
-        Assert.assertFalse(nullNotification.equals(integerNotification));
+        assertFalse(nullNotification.equals(integerNotification));
     }
 
     @Test
     public void testOnNextIntegerNotificationsWhenEqual(){
         final Notification<Integer> integerNotification = Notification.createOnNext(1);
         final Notification<Integer> integerNotification2 = Notification.createOnNext(1);
-        Assert.assertTrue(integerNotification.equals(integerNotification2));
+        assertTrue(integerNotification.equals(integerNotification2));
     }
 
     @Test
     public void testOnNextIntegerNotificationsWhenNotEqual(){
         final Notification<Integer> integerNotification = Notification.createOnNext(1);
         final Notification<Integer> integerNotification2 = Notification.createOnNext(2);
-        Assert.assertFalse(integerNotification.equals(integerNotification2));
+        assertFalse(integerNotification.equals(integerNotification2));
     }
 
     @Test
     public void testOnErrorIntegerNotificationDoesNotEqualNullNotification(){
         final Notification<Integer> integerNotification = Notification.createOnError(new Exception());
         final Notification<Integer> nullNotification = Notification.createOnError(null);
-        Assert.assertFalse(integerNotification.equals(nullNotification));
+        assertFalse(integerNotification.equals(nullNotification));
     }
 
     @Test
     public void testOnErrorNullNotificationDoesNotEqualIntegerNotification(){
         final Notification<Integer> integerNotification = Notification.createOnError(new Exception());
         final Notification<Integer> nullNotification = Notification.createOnError(null);
-        Assert.assertFalse(nullNotification.equals(integerNotification));
+        assertFalse(nullNotification.equals(integerNotification));
     }
 
     @Test
@@ -74,22 +75,22 @@ public void testOnErrorIntegerNotificationsWhenEqual(){
         final Exception exception = new Exception();
         final Notification<Integer> onErrorNotification = Notification.createOnError(exception);
         final Notification<Integer> onErrorNotification2 = Notification.createOnError(exception);
-        Assert.assertTrue(onErrorNotification.equals(onErrorNotification2));
+        assertTrue(onErrorNotification.equals(onErrorNotification2));
     }
 
     @Test
     public void testOnErrorIntegerNotificationWhenNotEqual(){
         final Notification<Integer> onErrorNotification = Notification.createOnError(new Exception());
         final Notification<Integer> onErrorNotification2 = Notification.createOnError(new Exception());
-        Assert.assertFalse(onErrorNotification.equals(onErrorNotification2));
+        assertFalse(onErrorNotification.equals(onErrorNotification2));
     }
 
     @Test
     public void createWithClass() {
         Notification<Integer> n = Notification.createOnCompleted(Integer.class);
-        Assert.assertTrue(n.isOnCompleted());
-        Assert.assertFalse(n.hasThrowable());
-        Assert.assertFalse(n.hasValue());
+        assertTrue(n.isOnCompleted());
+        assertFalse(n.hasThrowable());
+        assertFalse(n.hasValue());
     }
 
     @Test
@@ -121,9 +122,9 @@ static String stripAt(String s) {
 
     @Test
     public void toStringVariants() {
-        Assert.assertEquals("[rx.Notification OnNext 1]", stripAt(Notification.createOnNext(1).toString()));
-        Assert.assertEquals("[rx.Notification OnError Forced failure]", stripAt(Notification.createOnError(new TestException("Forced failure")).toString()));
-        Assert.assertEquals("[rx.Notification OnCompleted]", stripAt(Notification.createOnCompleted().toString()));
+        assertEquals("[rx.Notification OnNext 1]", stripAt(Notification.createOnNext(1).toString()));
+        assertEquals("[rx.Notification OnError Forced failure]", stripAt(Notification.createOnError(new TestException("Forced failure")).toString()));
+        assertEquals("[rx.Notification OnCompleted]", stripAt(Notification.createOnCompleted().toString()));
     }
 
     @Test
@@ -134,7 +135,7 @@ public void hashCodeWorks() {
         Notification<Integer> e1 = Notification.createOnError(new TestException());
         Notification<Integer> c1 = Notification.createOnCompleted();
 
-        Assert.assertEquals(n1.hashCode(), n1a.hashCode());
+        assertEquals(n1.hashCode(), n1a.hashCode());
 
         Set<Notification<Integer>> set = new HashSet<Notification<Integer>>();
 
@@ -143,11 +144,11 @@ public void hashCodeWorks() {
         set.add(e1);
         set.add(c1);
 
-        Assert.assertTrue(set.contains(n1));
-        Assert.assertTrue(set.contains(n1a));
-        Assert.assertTrue(set.contains(n2));
-        Assert.assertTrue(set.contains(e1));
-        Assert.assertTrue(set.contains(c1));
+        assertTrue(set.contains(n1));
+        assertTrue(set.contains(n1a));
+        assertTrue(set.contains(n2));
+        assertTrue(set.contains(e1));
+        assertTrue(set.contains(c1));
     }
 
     @Test
@@ -164,27 +165,27 @@ public void equalsWorks() {
         Notification<Integer> c1 = Notification.createOnCompleted();
         Notification<Integer> c2 = Notification.createOnCompleted();
 
-        Assert.assertEquals(n1, n1a);
-        Assert.assertNotEquals(n1, n2);
-        Assert.assertNotEquals(n2, n1);
+        assertEquals(n1, n1a);
+        assertNotEquals(n1, n2);
+        assertNotEquals(n2, n1);
 
-        Assert.assertNotEquals(n1, e1);
-        Assert.assertNotEquals(e1, n1);
-        Assert.assertNotEquals(e1, c1);
-        Assert.assertNotEquals(n1, c1);
-        Assert.assertNotEquals(c1, n1);
-        Assert.assertNotEquals(c1, e1);
+        assertNotEquals(n1, e1);
+        assertNotEquals(e1, n1);
+        assertNotEquals(e1, c1);
+        assertNotEquals(n1, c1);
+        assertNotEquals(c1, n1);
+        assertNotEquals(c1, e1);
 
-        Assert.assertEquals(e1, e1);
-        Assert.assertEquals(e1, e2);
+        assertEquals(e1, e1);
+        assertNotEquals(e1, e2);
 
-        Assert.assertEquals(c1, c2);
+        assertEquals(c1, c2);
 
-        Assert.assertFalse(n1.equals(null));
-        Assert.assertFalse(n1.equals(1));
+        assertFalse(n1.equals(null));
+        assertFalse(n1.equals(1));
         
-        Assert.assertEquals(z1a, z1);
-        Assert.assertEquals(z1, z1a);
+        assertEquals(z1a, z1);
+        assertEquals(z1, z1a);
     }
     
     @Test
@@ -195,25 +196,64 @@ public void contentChecks() {
         Notification<Integer> e2 = Notification.createOnError(null);
         Notification<Integer> c1 = Notification.createOnCompleted();
 
-        Assert.assertFalse(z1.hasValue());
-        Assert.assertFalse(z1.hasThrowable());
-        Assert.assertFalse(z1.isOnCompleted());
+        assertFalse(z1.hasValue());
+        assertFalse(z1.hasThrowable());
+        assertFalse(z1.isOnCompleted());
         
-        Assert.assertTrue(n1.hasValue());
-        Assert.assertFalse(n1.hasThrowable());
-        Assert.assertFalse(n1.isOnCompleted());
+        assertTrue(n1.hasValue());
+        assertFalse(n1.hasThrowable());
+        assertFalse(n1.isOnCompleted());
         
-        Assert.assertFalse(e1.hasValue());
-        Assert.assertTrue(e1.hasThrowable());
-        Assert.assertFalse(e1.isOnCompleted());
+        assertFalse(e1.hasValue());
+        assertTrue(e1.hasThrowable());
+        assertFalse(e1.isOnCompleted());
 
-        Assert.assertFalse(e2.hasValue());
-        Assert.assertFalse(e2.hasThrowable());
-        Assert.assertFalse(e2.isOnCompleted());
+        assertFalse(e2.hasValue());
+        assertFalse(e2.hasThrowable());
+        assertFalse(e2.isOnCompleted());
 
-        Assert.assertFalse(c1.hasValue());
-        Assert.assertFalse(c1.hasThrowable());
-        Assert.assertTrue(c1.isOnCompleted());
+        assertFalse(c1.hasValue());
+        assertFalse(c1.hasThrowable());
+        assertTrue(c1.isOnCompleted());
 
     }
+    
+    @Test
+    public void exceptionEquality() {
+        EqualException ex1 = new EqualException("1");
+        EqualException ex2 = new EqualException("1");
+        EqualException ex3 = new EqualException("3");
+        
+        Notification<Integer> e1 = Notification.createOnError(ex1);
+        Notification<Integer> e2 = Notification.createOnError(ex2);
+        Notification<Integer> e3 = Notification.createOnError(ex3);
+
+        assertEquals(e1, e1);
+        assertEquals(e1, e2);
+        assertEquals(e2, e1);
+        assertEquals(e2, e2);
+        
+        assertNotEquals(e1, e3);
+        assertNotEquals(e2, e3);
+        assertNotEquals(e3, e1);
+        assertNotEquals(e3, e2);
+    }
+    
+    static final class EqualException extends RuntimeException {
+        
+        /** */
+        private static final long serialVersionUID = 446310455393317050L;
+
+        public EqualException(String message) {
+            super(message);
+        }
+        
+        @Override
+        public boolean equals(Object o) {
+            if (o instanceof EqualException) {
+                return getMessage().equals(((EqualException)o).getMessage());
+            }
+            return false;
+        }
+    }
 }
diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
index 3dd215564a..273d705fba 100644
--- a/src/test/java/rx/ObservableTests.java
+++ b/src/test/java/rx/ObservableTests.java
@@ -28,10 +28,11 @@
 import org.mockito.*;
 
 import rx.Observable.*;
-import rx.exceptions.OnErrorNotImplementedException;
+import rx.exceptions.*;
 import rx.functions.*;
 import rx.observables.ConnectableObservable;
-import rx.observers.TestSubscriber;
+import rx.observers.*;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.*;
 import rx.subjects.*;
 import rx.subscriptions.BooleanSubscription;
@@ -1174,4 +1175,306 @@ public Object call(OnSubscribe<Object> onSubscribe) {
                 return subscriber.getOnNextEvents().get(0);
             }});
     }
+    
+    @Test
+    public void nullOnSubscribe() {
+        Observable<Integer> source = Observable.create((OnSubscribe<Integer>)null);
+        
+        try {
+            source.subscribe();
+            fail("Should have thrown IllegalStateException");
+        } catch (IllegalStateException ex) {
+            // expected
+        }
+    }
+    
+    @Test
+    public void nullObserver() {
+        Observable<Integer> source = Observable.just(1);
+        
+        try {
+            source.subscribe((Observer<Integer>)null);
+            fail("Should have thrown IllegalStateException");
+        } catch (NullPointerException ex) {
+            // expected
+        }
+    }
+
+    @Test
+    public void nullSubscriber() {
+        Observable<Integer> source = Observable.just(1);
+        
+        try {
+            source.subscribe((Subscriber<Integer>)null);
+            fail("Should have thrown IllegalStateException");
+        } catch (IllegalArgumentException ex) {
+            // expected
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void testCacheHint() throws InterruptedException {
+        final AtomicInteger counter = new AtomicInteger();
+        Observable<String> o = Observable.create(new OnSubscribe<String>() {
+
+            @Override
+            public void call(final Subscriber<? super String> observer) {
+                new Thread(new Runnable() {
+
+                    @Override
+                    public void run() {
+                        counter.incrementAndGet();
+                        observer.onNext("one");
+                        observer.onCompleted();
+                    }
+                }).start();
+            }
+        }).cache(1);
+
+        // we then expect the following 2 subscriptions to get that same value
+        final CountDownLatch latch = new CountDownLatch(2);
+
+        // subscribe once
+        o.subscribe(new Action1<String>() {
+
+            @Override
+            public void call(String v) {
+                assertEquals("one", v);
+                latch.countDown();
+            }
+        });
+
+        // subscribe again
+        o.subscribe(new Action1<String>() {
+
+            @Override
+            public void call(String v) {
+                assertEquals("one", v);
+                latch.countDown();
+            }
+        });
+
+        assertTrue("subscriptions did not receive values", latch.await(1000, TimeUnit.MILLISECONDS));
+        assertEquals(1, counter.get());
+    }
+    
+    @Test
+    public void subscribeWithNull() {
+        Action1<Integer> onNext = Actions.empty();
+        Action1<Throwable> onError = Actions.empty();
+        Action0 onCompleted = Actions.empty();
+        try {
+            Observable.just(1).subscribe((Action1<Integer>)null);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onNext can not be null", ex.getMessage());
+        }
+
+        try {
+            Observable.just(1).subscribe(null, onError);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onNext can not be null", ex.getMessage());
+        }
+
+        try {
+            Observable.just(1).subscribe(null, onError, onCompleted);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onNext can not be null", ex.getMessage());
+        }
+        
+        try {
+            Observable.just(1).subscribe(onNext, null);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onError can not be null", ex.getMessage());
+        }
+
+        try {
+            Observable.just(1).subscribe(onNext, null, onCompleted);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onError can not be null", ex.getMessage());
+        }
+        
+        try {
+            Observable.just(1).subscribe(onNext, onError, null);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onComplete can not be null", ex.getMessage());
+        }
+    }
+    
+    @Test
+    public void forEachWithNull() {
+        Action1<Integer> onNext = Actions.empty();
+        Action1<Throwable> onError = Actions.empty();
+        Action0 onCompleted = Actions.empty();
+        try {
+            Observable.just(1).forEach((Action1<Integer>)null);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onNext can not be null", ex.getMessage());
+        }
+
+        try {
+            Observable.just(1).forEach(null, onError);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onNext can not be null", ex.getMessage());
+        }
+
+        try {
+            Observable.just(1).forEach(null, onError, onCompleted);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onNext can not be null", ex.getMessage());
+        }
+        
+        try {
+            Observable.just(1).forEach(onNext, null);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onError can not be null", ex.getMessage());
+        }
+
+        try {
+            Observable.just(1).forEach(onNext, null, onCompleted);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onError can not be null", ex.getMessage());
+        }
+        
+        try {
+            Observable.just(1).forEach(onNext, onError, null);
+            fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("onComplete can not be null", ex.getMessage());
+        }
+    }
+    
+    @Test
+    public void observableThrowsWhileSubscriberIsUnsubscribed() {
+        TestSubscriber<Object> ts = TestSubscriber.create();
+        ts.unsubscribe();
+        
+        final List<Throwable> list = new ArrayList<Throwable>();
+        
+        RxJavaHooks.setOnError(new Action1<Throwable>() {
+            @Override
+            public void call(Throwable t) {
+                list.add(t);
+            }
+        });
+        
+        try {
+            new FailingObservable().subscribe(ts);
+            
+            assertEquals(1, list.size());
+            
+            assertEquals("Forced failure", list.get(0).getMessage());
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+    
+    @Test
+    public void observableThrowsWhileOnErrorFails() {
+        Subscriber<Object> ts = new SafeSubscriber<Object>(new TestSubscriber<Object>()) {
+            @Override
+            public void onError(Throwable e) {
+                throw new TestException("Forced failure");
+            }
+        };
+        
+        try {
+            new FailingObservable().subscribe(ts);
+            fail("Should have thrown OnErrorFailedException");
+        } catch (OnErrorFailedException ex) {
+            // expected
+            assertTrue(ex.getCause().toString(), ex.getCause() instanceof TestException);
+            assertEquals("Forced failure", ex.getCause().getMessage());
+        }
+    }
+    
+    @Test
+    public void observableThrowsWhileOnErrorFailsUnsafe() {
+        Subscriber<Object> ts = new TestSubscriber<Object>() {
+            @Override
+            public void onError(Throwable e) {
+                throw new TestException("Forced failure");
+            }
+        };
+        
+        try {
+            new FailingObservable().unsafeSubscribe(ts);
+            fail("Should have thrown OnErrorFailedException");
+        } catch (OnErrorFailedException ex) {
+            // expected
+            assertTrue(ex.getCause().toString(), ex.getCause() instanceof TestException);
+            assertEquals("Forced failure", ex.getCause().getMessage());
+        }
+    }
+    
+    static final class FailingObservable extends Observable<Object> {
+
+        protected FailingObservable() {
+            super(new OnSubscribe<Object>() {
+                @Override
+                public void call(Subscriber<? super Object> t) {
+                    throw new TestException("Forced failure");
+                }
+            });
+        }
+        
+    }
+    
+    @Test
+    public void forEachWithError() {
+        Action1<Throwable> onError = Actions.empty();
+
+        final List<Object> list = new ArrayList<Object>();
+        Observable.just(1).forEach(new Action1<Integer>() {
+            @Override
+            public void call(Integer t) {
+                list.add(t);
+            }
+        }, onError);
+        
+        Observable.<Integer>error(new TestException()).forEach(new Action1<Integer>() {
+            @Override
+            public void call(Integer t) {
+                list.add(t);
+            }
+        }, new Action1<Throwable>() {
+            @Override
+            public void call(Throwable t) {
+                list.add(t);
+            }
+        });
+        
+        Observable.<Integer>empty().forEach(new Action1<Integer>() {
+            @Override
+            public void call(Integer t) {
+                list.add(t);
+            }
+        }, new Action1<Throwable>() {
+            @Override
+            public void call(Throwable t) {
+                list.add(t);
+            }
+        }, new Action0() {
+            @Override
+            public void call() {
+                list.add(100);
+            }
+        });
+
+        assertEquals(3, list.size());
+        assertEquals(1, list.get(0));
+        assertTrue(list.get(1).toString(), list.get(1) instanceof TestException);
+        assertEquals(100, list.get(2));
+    }
 }
diff --git a/src/test/java/rx/ThrottleWithTimeoutTests.java b/src/test/java/rx/ThrottleWithTimeoutTests.java
index 0782b4ca6b..5bd336f74c 100644
--- a/src/test/java/rx/ThrottleWithTimeoutTests.java
+++ b/src/test/java/rx/ThrottleWithTimeoutTests.java
@@ -23,6 +23,7 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 
+import rx.observers.TestSubscriber;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -59,4 +60,17 @@ public void testThrottle() {
         inOrder.verify(observer).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
+    
+    @Test
+    public void timed() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(1, 2).throttleWithTimeout(1, TimeUnit.SECONDS).subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValue(2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+
+    }
 }
diff --git a/src/test/java/rx/exceptions/TestException.java b/src/test/java/rx/exceptions/TestException.java
index 34bcd8d68b..16422b7f25 100644
--- a/src/test/java/rx/exceptions/TestException.java
+++ b/src/test/java/rx/exceptions/TestException.java
@@ -33,14 +33,4 @@ public TestException() {
     public TestException(String message) {
         super(message);
     }
-    
-    @Override
-    public boolean equals(Object o) {
-        if (o == null || getClass() != o.getClass()) {
-            return false;
-        }
-        String thisMessage = getMessage();
-        String otherMessage = ((TestException)o).getMessage();
-        return thisMessage == otherMessage || (thisMessage != null && thisMessage.equals(otherMessage));
-    }
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java b/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java
index 4173c56eb5..0f70bd633c 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java
@@ -15,33 +15,27 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 import static rx.internal.operators.OnSubscribeAmb.amb;
 
 import java.io.IOException;
+import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
 
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.*;
 import org.mockito.InOrder;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Observer;
-import rx.Producer;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.functions.Action0;
-import rx.functions.Action1;
+import rx.exceptions.TestException;
+import rx.functions.*;
 import rx.internal.util.RxRingBuffer;
 import rx.observers.TestSubscriber;
-import rx.schedulers.Schedulers;
-import rx.schedulers.TestScheduler;
+import rx.schedulers.*;
+import rx.subjects.PublishSubject;
 import rx.subscriptions.CompositeSubscription;
 
 public class OnSubscribeAmbTest {
@@ -310,4 +304,173 @@ public void testMultipleUse() {
         ts2.assertCompleted();
         ts2.assertNoErrors();
     }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void ambIterable() {
+        PublishSubject<Integer> ps1 = PublishSubject.create();
+        PublishSubject<Integer> ps2 = PublishSubject.create();
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.amb(Arrays.asList(ps1, ps2)).subscribe(ts);
+        
+        ts.assertNoValues();
+        
+        ps1.onNext(1);
+        ps1.onCompleted();
+        
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void ambIterable2() {
+        PublishSubject<Integer> ps1 = PublishSubject.create();
+        PublishSubject<Integer> ps2 = PublishSubject.create();
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.amb(Arrays.asList(ps1, ps2)).subscribe(ts);
+        
+        ts.assertNoValues();
+        
+        ps2.onNext(2);
+        ps2.onCompleted();
+        
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+
+        ts.assertValue(2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void ambMany() throws Exception {
+        for (int i = 2; i < 10; i++) {
+            Class<?>[] clazz = new Class[i];
+            Arrays.fill(clazz, Observable.class);
+
+            PublishSubject<Integer>[] ps = new PublishSubject[i];
+
+            for (int j = 0; j < i; j++) {
+                
+                for (int k = 0; k < i; k++) {
+                    ps[k] = PublishSubject.create();
+                }
+                
+                Method m = Observable.class.getMethod("amb", clazz);
+                
+                Observable<Integer> obs = (Observable<Integer>)m.invoke(null, (Object[])ps);
+            
+                TestSubscriber<Integer> ts = TestSubscriber.create();
+                
+                obs.subscribe(ts);
+                
+                for (int k = 0; k < i; k++) {
+                    assertTrue("@" + i + "/" + k + " has no observers?", ps[k].hasObservers());
+                }
+                
+                ps[j].onNext(j);
+                ps[j].onCompleted();
+                
+                for (int k = 0; k < i; k++) {
+                    assertFalse("@" + i + "/" + k + " has observers?", ps[k].hasObservers());
+                }
+                
+                ts.assertValue(j);
+                ts.assertNoErrors();
+                ts.assertCompleted();
+            }
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void ambManyError() throws Exception {
+        for (int i = 2; i < 10; i++) {
+            Class<?>[] clazz = new Class[i];
+            Arrays.fill(clazz, Observable.class);
+
+            PublishSubject<Integer>[] ps = new PublishSubject[i];
+
+            for (int j = 0; j < i; j++) {
+                
+                for (int k = 0; k < i; k++) {
+                    ps[k] = PublishSubject.create();
+                }
+                
+                Method m = Observable.class.getMethod("amb", clazz);
+                
+                Observable<Integer> obs = (Observable<Integer>)m.invoke(null, (Object[])ps);
+            
+                TestSubscriber<Integer> ts = TestSubscriber.create();
+                
+                obs.subscribe(ts);
+                
+                for (int k = 0; k < i; k++) {
+                    assertTrue("@" + i + "/" + k + " has no observers?", ps[k].hasObservers());
+                }
+                
+                ps[j].onError(new TestException(Integer.toString(j)));
+                
+                for (int k = 0; k < i; k++) {
+                    assertFalse("@" + i + "/" + k + " has observers?", ps[k].hasObservers());
+                }
+                
+                ts.assertNoValues();
+                ts.assertError(TestException.class);
+                ts.assertNotCompleted();
+                
+                assertEquals(Integer.toString(j), ts.getOnErrorEvents().get(0).getMessage());
+            }
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void ambManyComplete() throws Exception {
+        for (int i = 2; i < 10; i++) {
+            Class<?>[] clazz = new Class[i];
+            Arrays.fill(clazz, Observable.class);
+
+            PublishSubject<Integer>[] ps = new PublishSubject[i];
+
+            for (int j = 0; j < i; j++) {
+                
+                for (int k = 0; k < i; k++) {
+                    ps[k] = PublishSubject.create();
+                }
+                
+                Method m = Observable.class.getMethod("amb", clazz);
+                
+                Observable<Integer> obs = (Observable<Integer>)m.invoke(null, (Object[])ps);
+            
+                TestSubscriber<Integer> ts = TestSubscriber.create();
+                
+                obs.subscribe(ts);
+                
+                for (int k = 0; k < i; k++) {
+                    assertTrue("@" + i + "/" + k + " has no observers?", ps[k].hasObservers());
+                }
+                
+                ps[j].onCompleted();
+                
+                for (int k = 0; k < i; k++) {
+                    assertFalse("@" + i + "/" + k + " has observers?", ps[k].hasObservers());
+                }
+                
+                ts.assertNoValues();
+                ts.assertNoErrors();
+                ts.assertCompleted();
+            }
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java b/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java
index 840077af59..7eb2f1b11d 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java
@@ -1058,4 +1058,23 @@ public Integer call(Object... args) {
         ts.assertNotCompleted();
     }
 
+    @SuppressWarnings("unchecked")
+    @Test
+    public void combineLatestIterable() {
+        Observable<Integer> source = Observable.just(1);
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.combineLatest((Iterable<Observable<Integer>>)Arrays.asList(source, source), new FuncN<Integer>() {
+            @Override
+            public Integer call(Object... args) {
+                return (Integer)args[0] + (Integer)args[1];
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue(2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
index b61630f837..6fd947ae60 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
@@ -16,6 +16,10 @@
 
 package rx.internal.operators;
 
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+
 import org.junit.Test;
 
 import rx.Observable;
@@ -210,4 +214,67 @@ public Observable<Integer> call(Integer v) {
         ts.assertCompleted();
     }
 
+    static <T> Observable<T> withError(Observable<T> source) {
+        return source.concatWith(Observable.<T>error(new TestException()));
+    }
+    
+
+    @Test
+    public void concatDelayErrorObservable() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.concatDelayError(
+                Observable.just(Observable.just(1), Observable.just(2)))
+        .subscribe(ts);
+        
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void concatDelayErrorObservableError() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.concatDelayError(
+                withError(Observable.just(withError(Observable.just(1)), withError(Observable.just(2)))))
+        .subscribe(ts);
+        
+        ts.assertValues(1, 2);
+        ts.assertError(CompositeException.class);
+        ts.assertNotCompleted();
+        
+        assertEquals(3, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayErrorIterable() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.concatDelayError(
+                Arrays.asList(Observable.just(1), Observable.just(2)))
+        .subscribe(ts);
+        
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayErrorIterableError() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.concatDelayError(
+                Arrays.asList(withError(Observable.just(1)), withError(Observable.just(2))))
+        .subscribe(ts);
+        
+        ts.assertValues(1, 2);
+        ts.assertError(CompositeException.class);
+        ts.assertNotCompleted();
+        
+        assertEquals(2, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
+    }
+
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeDelaySubscriptionOtherTest.java b/src/test/java/rx/internal/operators/OnSubscribeDelaySubscriptionOtherTest.java
index b44b720b41..d0f2aec125 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeDelaySubscriptionOtherTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeDelaySubscriptionOtherTest.java
@@ -308,4 +308,8 @@ public void call() {
         Assert.assertFalse(subscribed.get());
     }
 
+    @Test(expected = NullPointerException.class)
+    public void otherNull() {
+        Observable.just(1).delaySubscription((Observable<Integer>)null);
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java b/src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java
index 7158456a35..af4f989ce6 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java
@@ -23,7 +23,7 @@
 
 import rx.Observable;
 import rx.exceptions.TestException;
-import rx.functions.Func1;
+import rx.functions.*;
 import rx.observers.TestSubscriber;
 import rx.subjects.PublishSubject;
 
@@ -48,6 +48,18 @@ public void normal() {
         ts.assertCompleted();
     }
 
+    @Test
+    public void normalViaFlatMap() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        Observable.range(1, 5).flatMapIterable(mapper)
+        .subscribe(ts);
+        
+        ts.assertValues(1, 2, 2, 3, 3, 4, 4, 5, 5, 6);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
     @Test
     public void normalBackpressured() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
@@ -474,4 +486,39 @@ public Iterable<Integer> call(Integer v) {
         Assert.assertFalse("PublishSubject has Observers?!", ps.hasObservers());
         Assert.assertEquals(1, counter.get());
     }
+    
+    @Test
+    public void normalPrefetchViaFlatMap() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        Observable.range(1, 5).flatMapIterable(mapper, 2)
+        .subscribe(ts);
+        
+        ts.assertValues(1, 2, 2, 3, 3, 4, 4, 5, 5, 6);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void withResultSelectorMaxConcurrent() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(1, 5).flatMapIterable(new Func1<Integer, Iterable<Integer>>() {
+            @Override
+            public Iterable<Integer> call(Integer v) {
+                return Collections.singletonList(1);
+            }
+        }, new Func2<Integer, Integer, Integer>() {
+            @Override
+            public Integer call(Integer a, Integer b) {
+                return a * 10 + b;
+            }
+        }, 2)
+        .subscribe(ts)
+        ;
+        
+        ts.assertValues(11, 21, 31, 41, 51);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java
index 3b7ec5220b..1b427bbdda 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java
@@ -16,9 +16,10 @@
 
 package rx.internal.operators;
 
-import org.junit.Test;
+import org.junit.*;
 
 import rx.Observable;
+import rx.internal.util.ScalarSynchronousObservable;
 import rx.observers.TestSubscriber;
 
 public class OnSubscribeFromArrayTest {
@@ -64,4 +65,15 @@ public void backpressure() {
         ts.assertCompleted();
     }
 
+    @Test
+    public void empty() {
+        Assert.assertSame(Observable.empty(), Observable.from(new Object[0]));
+    }
+
+    @Test
+    public void just() {
+        Observable<Integer> source = Observable.from(new Integer[] { 1 });
+        Assert.assertTrue(source.getClass().toString(), source instanceof ScalarSynchronousObservable);
+    }
+
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeRangeTest.java b/src/test/java/rx/internal/operators/OnSubscribeRangeTest.java
index acc2f6ff75..7838f30474 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeRangeTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeRangeTest.java
@@ -15,22 +15,13 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.*;
+import java.util.concurrent.atomic.*;
 
-import org.junit.Test;
+import org.junit.*;
 
 import rx.Observable;
 import rx.Observer;
@@ -268,4 +259,14 @@ public void testNearMaxValueWithBackpressure() {
         ts.assertNoErrors();
         ts.assertValues(Integer.MAX_VALUE - 1, Integer.MAX_VALUE);
     }
+    
+    @Test
+    public void negativeCount() {
+        try {
+            Observable.range(1, -1);
+            Assert.fail("Should have thrown IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            Assert.assertEquals("Count can not be negative", ex.getMessage());
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeTimerTest.java b/src/test/java/rx/internal/operators/OnSubscribeTimerTest.java
index 99c677cedb..d520d15c75 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeTimerTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeTimerTest.java
@@ -37,6 +37,7 @@
 import rx.Subscription;
 import rx.exceptions.TestException;
 import rx.observables.ConnectableObservable;
+import rx.observers.TestSubscriber;
 import rx.schedulers.TestScheduler;
 
 public class OnSubscribeTimerTest {
@@ -292,4 +293,44 @@ public void onCompleted() {
         inOrder.verifyNoMoreInteractions();
         verify(observer, never()).onCompleted();
     }
+
+    @Test
+    public void timerInterval() {
+        @SuppressWarnings("deprecation")
+        Observable<Long> w = Observable.timer(1, 1, TimeUnit.SECONDS, scheduler);
+        Subscription sub = w.subscribe(observer);
+
+        verify(observer, never()).onNext(0L);
+        verify(observer, never()).onCompleted();
+        verify(observer, never()).onError(any(Throwable.class));
+
+        scheduler.advanceTimeTo(2, TimeUnit.SECONDS);
+
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(0L);
+        inOrder.verify(observer, times(1)).onNext(1L);
+        inOrder.verify(observer, never()).onNext(2L);
+        verify(observer, never()).onCompleted();
+        verify(observer, never()).onError(any(Throwable.class));
+
+        sub.unsubscribe();
+        scheduler.advanceTimeTo(4, TimeUnit.SECONDS);
+        verify(observer, never()).onNext(2L);
+        verify(observer, never()).onCompleted();
+        verify(observer, never()).onError(any(Throwable.class));
+    }
+
+    @Test
+    public void timerIntervalDefaultScheduler() {
+        @SuppressWarnings("deprecation")
+        Observable<Long> source = Observable.timer(1, 1, TimeUnit.MILLISECONDS).take(100);
+        
+        TestSubscriber<Long> ts = TestSubscriber.create();
+        source.subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValueCount(100);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
index 8ae5307738..b85a7c26a7 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
@@ -156,4 +156,63 @@ public void run() {
         ts.assertNoErrors();
         ts.assertCompleted();
     }
+    
+    @Test
+    public void withTimeoutNoTimeout() {
+        FutureTask<Integer> task = new FutureTask<Integer>(new Runnable() {
+            @Override
+            public void run() {
+                
+            }
+        }, 1);
+        
+        task.run();
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.from(task, 1, TimeUnit.SECONDS).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void withTimeoutTimeout() {
+        FutureTask<Integer> task = new FutureTask<Integer>(new Runnable() {
+            @Override
+            public void run() {
+                
+            }
+        }, 1);
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.from(task, 10, TimeUnit.MILLISECONDS).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(TimeoutException.class);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void withTimeoutNoTimeoutScheduler() {
+        FutureTask<Integer> task = new FutureTask<Integer>(new Runnable() {
+            @Override
+            public void run() {
+                
+            }
+        }, 1);
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.from(task, Schedulers.computation()).subscribe(ts);
+
+        task.run();
+
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorBufferTest.java b/src/test/java/rx/internal/operators/OperatorBufferTest.java
index ad8b1bc9c7..1c0202e9ed 100644
--- a/src/test/java/rx/internal/operators/OperatorBufferTest.java
+++ b/src/test/java/rx/internal/operators/OperatorBufferTest.java
@@ -15,39 +15,24 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.*;
 import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
+import static org.mockito.Mockito.*;
+
+import java.util.*;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicLong;
 
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mockito;
+import org.junit.*;
+import org.mockito.*;
 
+import rx.*;
 import rx.Observable;
 import rx.Observer;
-import rx.Producer;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.Subscription;
 import rx.exceptions.TestException;
-import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.functions.Func0;
-import rx.functions.Func1;
+import rx.functions.*;
 import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -1092,4 +1077,180 @@ public void testPostCompleteBackpressure() {
         ts.assertCompleted();
         ts.assertNoErrors();
     }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void timeAndSkipOverlap() {
+        
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+        
+        ps.buffer(2, 1, TimeUnit.SECONDS, scheduler).subscribe(ts);
+        
+        ps.onNext(1);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        ps.onNext(2);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        ps.onNext(3);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        ps.onNext(4);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        ps.onCompleted();
+        
+        ts.assertValues(
+                Arrays.asList(1, 2),
+                Arrays.asList(2, 3),
+                Arrays.asList(3, 4),
+                Arrays.asList(4),
+                Collections.<Integer>emptyList()
+        );
+        
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void timeAndSkipSkip() {
+        
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+        
+        ps.buffer(2, 3, TimeUnit.SECONDS, scheduler).subscribe(ts);
+        
+        ps.onNext(1);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        ps.onNext(2);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        ps.onNext(3);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        ps.onNext(4);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        ps.onCompleted();
+        
+        ts.assertValues(
+                Arrays.asList(1, 2),
+                Arrays.asList(4)
+        );
+        
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void timeAndSkipOverlapScheduler() {
+        
+        RxJavaHooks.setOnComputationScheduler(new Func1<Scheduler, Scheduler>() {
+            @Override
+            public Scheduler call(Scheduler t) {
+                return scheduler;
+            }
+        });
+        
+        try {
+            PublishSubject<Integer> ps = PublishSubject.create();
+            
+            TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+            
+            ps.buffer(2, 1, TimeUnit.SECONDS).subscribe(ts);
+            
+            ps.onNext(1);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+            
+            ps.onNext(2);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+    
+            ps.onNext(3);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+    
+            ps.onNext(4);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+            
+            ps.onCompleted();
+            
+            ts.assertValues(
+                    Arrays.asList(1, 2),
+                    Arrays.asList(2, 3),
+                    Arrays.asList(3, 4),
+                    Arrays.asList(4),
+                    Collections.<Integer>emptyList()
+            );
+            
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void timeAndSkipSkipDefaultScheduler() {
+        RxJavaHooks.setOnComputationScheduler(new Func1<Scheduler, Scheduler>() {
+            @Override
+            public Scheduler call(Scheduler t) {
+                return scheduler;
+            }
+        });
+        
+        try {
+        
+            PublishSubject<Integer> ps = PublishSubject.create();
+            
+            TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+            
+            ps.buffer(2, 3, TimeUnit.SECONDS).subscribe(ts);
+            
+            ps.onNext(1);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+            
+            ps.onNext(2);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+    
+            ps.onNext(3);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+    
+            ps.onNext(4);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+            
+            ps.onCompleted();
+            
+            ts.assertValues(
+                    Arrays.asList(1, 2),
+                    Arrays.asList(4)
+            );
+            
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorConcatTest.java b/src/test/java/rx/internal/operators/OperatorConcatTest.java
index 65487798b9..06b889a4e8 100644
--- a/src/test/java/rx/internal/operators/OperatorConcatTest.java
+++ b/src/test/java/rx/internal/operators/OperatorConcatTest.java
@@ -15,33 +15,26 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.lang.reflect.Method;
+import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
 import org.junit.Test;
 import org.mockito.InOrder;
 
-import rx.Observable.OnSubscribe;
 import rx.*;
-import rx.functions.Func1;
-import rx.internal.util.RxRingBuffer;
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Observer;
+import rx.functions.*;
+import rx.internal.util.*;
 import rx.observers.TestSubscriber;
-import rx.schedulers.Schedulers;
-import rx.schedulers.TestScheduler;
+import rx.schedulers.*;
 import rx.subjects.*;
 import rx.subscriptions.BooleanSubscription;
 
@@ -911,4 +904,102 @@ public void emptyAndScalarBackpressured() {
         ts.assertNoErrors();
     }
 
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatMany() throws Exception {
+        for (int i = 2; i < 10; i++) {
+            Class<?>[] clazz = new Class[i];
+            Arrays.fill(clazz, Observable.class);
+            
+            Observable<Integer>[] obs = new Observable[i];
+            Arrays.fill(obs, Observable.just(1));
+            
+            Integer[] expected = new Integer[i];
+            Arrays.fill(expected, 1);
+            
+            Method m = Observable.class.getMethod("concat", clazz);
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            ((Observable<Integer>)m.invoke(null, (Object[])obs)).subscribe(ts);
+            
+            ts.assertValues(expected);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        }
+    }
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void concatMapJustJust() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(Observable.just(1)).concatMap((Func1)UtilityFunctions.identity()).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void concatMapJustRange() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(Observable.range(1, 5)).concatMap((Func1)UtilityFunctions.identity()).subscribe(ts);
+        
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void concatMapDelayErrorJustJust() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(Observable.just(1)).concatMapDelayError((Func1)UtilityFunctions.identity()).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void concatMapDelayErrorJustRange() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(Observable.range(1, 5)).concatMapDelayError((Func1)UtilityFunctions.identity()).subscribe(ts);
+        
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void startWith() throws Exception {
+        for (int i = 2; i < 10; i++) {
+            Class<?>[] clazz = new Class[i];
+            Arrays.fill(clazz, Object.class);
+            
+            Object[] obs = new Object[i];
+            Arrays.fill(obs, 1);
+            
+            Integer[] expected = new Integer[i];
+            Arrays.fill(expected, 1);
+            
+            Method m = Observable.class.getMethod("startWith", clazz);
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            ((Observable<Integer>)m.invoke(Observable.empty(), obs)).subscribe(ts);
+            
+            ts.assertValues(expected);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        }
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/rx/internal/operators/OperatorDebounceTest.java b/src/test/java/rx/internal/operators/OperatorDebounceTest.java
index e43efa2f7f..4a33c662cd 100644
--- a/src/test/java/rx/internal/operators/OperatorDebounceTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDebounceTest.java
@@ -305,4 +305,17 @@ public void debounceWithTimeBackpressure() throws InterruptedException {
         subscriber.assertTerminalEvent();
         subscriber.assertNoErrors();
     }
+    
+    @Test
+    public void debounceDefaultScheduler() throws Exception {
+        
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+
+        Observable.range(1, 1000).debounce(1, TimeUnit.SECONDS).subscribe(ts);
+
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValue(1000);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/internal/operators/OperatorDoAfterTerminateTest.java b/src/test/java/rx/internal/operators/OperatorDoAfterTerminateTest.java
index 397451161d..d0dc6fa408 100644
--- a/src/test/java/rx/internal/operators/OperatorDoAfterTerminateTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDoAfterTerminateTest.java
@@ -94,4 +94,12 @@ public void ifFinallyActionThrowsExceptionShouldNotBeSwallowedAndActionShouldBeC
         // Not only IllegalStateException was swallowed
         // But finallyAction was called twice!
     }
+    
+    @SuppressWarnings("deprecation")
+    @Test
+    public void finallyDo() {
+        Observable.empty().finallyDo(aAction0).subscribe();
+        
+        verify(aAction0).call();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorEagerConcatMapTest.java b/src/test/java/rx/internal/operators/OperatorEagerConcatMapTest.java
index e6298230e4..737b331dfe 100644
--- a/src/test/java/rx/internal/operators/OperatorEagerConcatMapTest.java
+++ b/src/test/java/rx/internal/operators/OperatorEagerConcatMapTest.java
@@ -16,8 +16,8 @@
 
 package rx.internal.operators;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.lang.reflect.Method;
+import java.util.*;
 import java.util.concurrent.atomic.*;
 
 import org.junit.*;
@@ -25,11 +25,13 @@
 import rx.Observable;
 import rx.exceptions.TestException;
 import rx.functions.*;
-import rx.internal.util.RxRingBuffer;
+import rx.internal.util.*;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
 
+import static org.junit.Assert.*;
+
 public class OperatorEagerConcatMapTest {
     TestSubscriber<Object> ts;
     TestSubscriber<Object> tsBp;
@@ -438,4 +440,91 @@ public void call(Long reqCount) {
         Assert.assertEquals(1, (long) requests.get(4));
         Assert.assertEquals(1, (long) requests.get(5));
     }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void many() throws Exception {
+        for (int i = 2; i < 10; i++) {
+            Class<?>[] clazz = new Class[i];
+            Arrays.fill(clazz, Observable.class);
+            
+            Observable<Integer>[] obs = new Observable[i];
+            Arrays.fill(obs, Observable.just(1));
+            
+            Integer[] expected = new Integer[i];
+            Arrays.fill(expected, 1);
+            
+            Method m = Observable.class.getMethod("concatEager", clazz);
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            ((Observable<Integer>)m.invoke(null, (Object[])obs)).subscribe(ts);
+            
+            ts.assertValues(expected);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void capacityHint() {
+        Observable<Integer> source = Observable.just(1);
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+
+        Observable.concatEager(Arrays.asList(source, source, source), 1).subscribe(ts);
+        
+        ts.assertValues(1, 1, 1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void observable() {
+        Observable<Integer> source = Observable.just(1);
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+
+        Observable.concatEager(Observable.just(source, source, source)).subscribe(ts);
+        
+        ts.assertValues(1, 1, 1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void observableCapacityHint() {
+        Observable<Integer> source = Observable.just(1);
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+
+        Observable.concatEager(Observable.just(source, source, source), 1).subscribe(ts);
+        
+        ts.assertValues(1, 1, 1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void badCapacityHint() throws Exception {
+        Observable<Integer> source = Observable.just(1);
+        try {
+            Observable.concatEager(Arrays.asList(source, source, source), -99);
+        } catch (IllegalArgumentException ex) {
+            assertEquals("capacityHint > 0 required but it was -99", ex.getMessage());
+        }
+        
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void mappingBadCapacityHint() throws Exception {
+        Observable<Integer> source = Observable.just(1);
+        try {
+            Observable.just(source, source, source).concatMapEager((Func1)UtilityFunctions.identity(), -99, 10);
+        } catch (IllegalArgumentException ex) {
+            assertEquals("capacityHint > 0 required but it was -99", ex.getMessage());
+        }
+        
+    }
+
 }
diff --git a/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java b/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java
index e5088a0a4a..2468eb7b0a 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java
@@ -20,6 +20,7 @@
 import static org.mockito.Matchers.anyInt;
 import static org.mockito.Mockito.*;
 
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -40,6 +41,7 @@
 import rx.exceptions.TestException;
 import rx.functions.Action1;
 import rx.observers.TestSubscriber;
+import rx.subjects.PublishSubject;
 
 public class OperatorMergeDelayErrorTest {
 
@@ -594,4 +596,122 @@ public void call(Long t1) {
         assertTrue(ts.getOnErrorEvents().get(0) instanceof TestException);
         assertEquals(Arrays.asList(1L, 1L, 1L), requests);
     }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void iterableMaxConcurrent() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+
+        PublishSubject<Integer> ps1 = PublishSubject.create();
+        PublishSubject<Integer> ps2 = PublishSubject.create();
+        
+        Observable.mergeDelayError(Arrays.asList(ps1, ps2), 1).subscribe(ts);
+        
+        assertTrue("ps1 has no subscribers?!", ps1.hasObservers());
+        assertFalse("ps2 has subscribers?!", ps2.hasObservers());
+        
+        ps1.onNext(1);
+        ps1.onCompleted();
+        
+        assertFalse("ps1 has subscribers?!", ps1.hasObservers());
+        assertTrue("ps2 has no subscribers?!", ps2.hasObservers());
+
+        ps2.onNext(2);
+        ps2.onCompleted();
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void iterableMaxConcurrentError() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+
+        PublishSubject<Integer> ps1 = PublishSubject.create();
+        PublishSubject<Integer> ps2 = PublishSubject.create();
+        
+        Observable.mergeDelayError(Arrays.asList(ps1, ps2), 1).subscribe(ts);
+        
+        assertTrue("ps1 has no subscribers?!", ps1.hasObservers());
+        assertFalse("ps2 has subscribers?!", ps2.hasObservers());
+        
+        ps1.onNext(1);
+        ps1.onError(new TestException());
+        
+        assertFalse("ps1 has subscribers?!", ps1.hasObservers());
+        assertTrue("ps2 has no subscribers?!", ps2.hasObservers());
+
+        ps2.onNext(2);
+        ps2.onError(new TestException());
+
+        ts.assertValues(1, 2);
+        ts.assertError(CompositeException.class);
+        ts.assertNotCompleted();
+        
+        CompositeException ce = (CompositeException)ts.getOnErrorEvents().get(0);
+        
+        assertEquals(2, ce.getExceptions().size());
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void mergeMany() throws Exception {
+        for (int i = 2; i < 10; i++) {
+            Class<?>[] clazz = new Class[i];
+            Arrays.fill(clazz, Observable.class);
+            
+            Observable<Integer>[] obs = new Observable[i];
+            Arrays.fill(obs, Observable.just(1));
+            
+            Integer[] expected = new Integer[i];
+            Arrays.fill(expected, 1);
+            
+            Method m = Observable.class.getMethod("mergeDelayError", clazz);
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            ((Observable<Integer>)m.invoke(null, (Object[])obs)).subscribe(ts);
+            
+            ts.assertValues(expected);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        }
+    }
+
+    static <T> Observable<T> withError(Observable<T> source) {
+        return source.concatWith(Observable.<T>error(new TestException()));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void mergeManyError() throws Exception {
+        for (int i = 2; i < 10; i++) {
+            Class<?>[] clazz = new Class[i];
+            Arrays.fill(clazz, Observable.class);
+            
+            Observable<Integer>[] obs = new Observable[i];
+            for (int j = 0; j < i; j++) {
+                obs[j] = withError(Observable.just(1));
+            }
+            
+            Integer[] expected = new Integer[i];
+            Arrays.fill(expected, 1);
+            
+            Method m = Observable.class.getMethod("mergeDelayError", clazz);
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            ((Observable<Integer>)m.invoke(null, (Object[])obs)).subscribe(ts);
+            
+            ts.assertValues(expected);
+            ts.assertError(CompositeException.class);
+            ts.assertNotCompleted();
+            
+            CompositeException ce = (CompositeException)ts.getOnErrorEvents().get(0);
+            
+            assertEquals(i, ce.getExceptions().size());
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorMergeTest.java b/src/test/java/rx/internal/operators/OperatorMergeTest.java
index f410a55685..8f6e2a2aa2 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeTest.java
@@ -20,6 +20,7 @@
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.*;
 
+import java.lang.reflect.Method;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
@@ -33,9 +34,10 @@
 import rx.Observer;
 import rx.Scheduler.Worker;
 import rx.functions.*;
-import rx.internal.util.RxRingBuffer;
+import rx.internal.util.*;
 import rx.observers.TestSubscriber;
 import rx.schedulers.*;
+import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 
 public class OperatorMergeTest {
@@ -1373,4 +1375,127 @@ public Observable<Integer> call(Integer t) {
         ts.assertNoErrors();
         ts.assertCompleted();
     }
+    
+    @Test
+    public void mergeConcurrentJustJust() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.merge(Observable.just(Observable.just(1)), 5).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void mergeConcurrentJustRange() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.merge(Observable.just(Observable.range(1, 5)), 5).subscribe(ts);
+        
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void mergeMany() throws Exception {
+        for (int i = 2; i < 10; i++) {
+            Class<?>[] clazz = new Class[i];
+            Arrays.fill(clazz, Observable.class);
+            
+            Observable<Integer>[] obs = new Observable[i];
+            Arrays.fill(obs, Observable.just(1));
+            
+            Integer[] expected = new Integer[i];
+            Arrays.fill(expected, 1);
+            
+            Method m = Observable.class.getMethod("merge", clazz);
+            
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            ((Observable<Integer>)m.invoke(null, (Object[])obs)).subscribe(ts);
+            
+            ts.assertValues(expected);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Test
+    public void mergeArrayMaxConcurrent() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+
+        PublishSubject<Integer> ps1 = PublishSubject.create();
+        PublishSubject<Integer> ps2 = PublishSubject.create();
+        
+        Observable.merge(new Observable[] { ps1, ps2 }, 1).subscribe(ts);
+        
+        assertTrue("ps1 has no subscribers?!", ps1.hasObservers());
+        assertFalse("ps2 has subscribers?!", ps2.hasObservers());
+        
+        ps1.onNext(1);
+        ps1.onCompleted();
+        
+        assertFalse("ps1 has subscribers?!", ps1.hasObservers());
+        assertTrue("ps2 has no subscribers?!", ps2.hasObservers());
+
+        ps2.onNext(2);
+        ps2.onCompleted();
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void flatMapJustJust() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(Observable.just(1)).flatMap((Func1)UtilityFunctions.identity()).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void flatMapJustRange() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(Observable.range(1, 5)).flatMap((Func1)UtilityFunctions.identity()).subscribe(ts);
+        
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void flatMapMaxConcurrentJustJust() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(Observable.just(1)).flatMap((Func1)UtilityFunctions.identity(), 5).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void flatMapMaxConcurrentJustRange() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(Observable.range(1, 5)).flatMap((Func1)UtilityFunctions.identity(), 5).subscribe(ts);
+        
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
index ac01daa591..4008708084 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
@@ -264,4 +264,14 @@ public void call(Throwable t) {
          assertFalse(errorOccurred.get());
     }
 
+    @Test
+    public void maxSize() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        
+        Observable.range(1, 10).onBackpressureBuffer(1).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(MissingBackpressureException.class);
+        ts.assertNotCompleted();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorRepeatTest.java b/src/test/java/rx/internal/operators/OperatorRepeatTest.java
index 44371867c5..6e4fff4715 100644
--- a/src/test/java/rx/internal/operators/OperatorRepeatTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRepeatTest.java
@@ -15,8 +15,7 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.*;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.*;
 
@@ -199,4 +198,52 @@ public Observable<Integer> call(Integer x) {
         
         assertEquals(Arrays.asList(1, 2, 1, 2, 1, 2, 1, 2, 1, 2), concatBase);
     }
+    
+    @Test
+    public void repeatScheduled() {
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(1).repeat(5, Schedulers.computation()).subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValues(1, 1, 1, 1, 1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    @Test
+    public void repeatWhenDefaultScheduler() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(1).repeatWhen((Func1)new Func1<Observable, Observable>() {
+            @Override
+            public Observable call(Observable o) {
+                return o.take(2);
+            }
+        }).subscribe(ts);
+        
+        ts.assertValues(1, 1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+    }
+    
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    @Test
+    public void repeatWhenTrampolineScheduler() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(1).repeatWhen((Func1)new Func1<Observable, Observable>() {
+            @Override
+            public Observable call(Observable o) {
+                return o.take(2);
+            }
+        }, Schedulers.trampoline()).subscribe(ts);
+        
+        ts.assertValues(1, 1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorReplayTest.java b/src/test/java/rx/internal/operators/OperatorReplayTest.java
index fb741991d7..fafe4ebc58 100644
--- a/src/test/java/rx/internal/operators/OperatorReplayTest.java
+++ b/src/test/java/rx/internal/operators/OperatorReplayTest.java
@@ -16,41 +16,28 @@
 package rx.internal.operators;
 
 import static org.junit.Assert.*;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.notNull;
+import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.*;
 import org.mockito.InOrder;
 
+import rx.*;
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
-import rx.Scheduler;
 import rx.Scheduler.Worker;
-import rx.Subscriber;
-import rx.Subscription;
 import rx.exceptions.TestException;
-import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.functions.Func1;
-import rx.internal.operators.OperatorReplay.BoundedReplayBuffer;
-import rx.internal.operators.OperatorReplay.Node;
-import rx.internal.operators.OperatorReplay.SizeAndTimeBoundReplayBuffer;
+import rx.functions.*;
+import rx.internal.operators.OperatorReplay.*;
 import rx.internal.util.PlatformDependent;
 import rx.observables.ConnectableObservable;
 import rx.observers.TestSubscriber;
-import rx.schedulers.Schedulers;
-import rx.schedulers.TestScheduler;
+import rx.schedulers.*;
 import rx.subjects.PublishSubject;
 
 public class OperatorReplayTest {
@@ -1297,4 +1284,215 @@ public void dontReplayOldValues() {
         
         ts.assertValue(3);
     }
+    
+    @Test
+    public void invalidBufferSize() {
+        try {
+            Observable.just(1).replay(-1, 1, TimeUnit.MILLISECONDS);
+        } catch (IllegalArgumentException ex) {
+            assertEquals("bufferSize < 0", ex.getMessage());
+        }
+    }
+    
+    @Test
+    public void bufferScheduled() {
+        
+        TestScheduler test = new TestScheduler();
+        
+        
+        ConnectableObservable<Integer> co = Observable.range(1, 5).replay(2, test);
+        
+        TestSubscriber<Integer> ts1 = TestSubscriber.create();
+        
+        co.subscribe(ts1);
+        
+        co.connect();
+        
+        ts1.assertNoValues();
+        ts1.assertNotCompleted();
+        
+        test.triggerActions();
+        
+        ts1.assertValues(1, 2, 3, 4, 5);
+        ts1.assertNoErrors();
+        ts1.assertCompleted();
+        
+        TestSubscriber<Integer> ts2 = TestSubscriber.create();
+        
+        co.subscribe(ts2);
+        
+        ts2.assertNoValues();
+        ts2.assertNotCompleted();
+        
+        test.triggerActions();
+        
+        ts2.assertValues(4, 5);
+        ts2.assertNoErrors();
+        ts2.assertCompleted();
+    }
+    
+    @Test
+    public void allScheduled() {
+        
+        TestScheduler test = new TestScheduler();
+        
+        
+        ConnectableObservable<Integer> co = Observable.range(1, 5).replay(test);
+        
+        TestSubscriber<Integer> ts1 = TestSubscriber.create();
+        
+        co.subscribe(ts1);
+        
+        co.connect();
+        
+        ts1.assertNoValues();
+        ts1.assertNotCompleted();
+        
+        test.triggerActions();
+        
+        ts1.assertValues(1, 2, 3, 4, 5);
+        ts1.assertNoErrors();
+        ts1.assertCompleted();
+        
+        TestSubscriber<Integer> ts2 = TestSubscriber.create();
+        
+        co.subscribe(ts2);
+        
+        ts2.assertNoValues();
+        ts2.assertNotCompleted();
+        
+        test.triggerActions();
+        
+        ts2.assertValues(1, 2, 3, 4, 5);
+        ts2.assertNoErrors();
+        ts2.assertCompleted();
+    }
+
+    @Test
+    public void replayTimedDefaultScheduler() {
+        ConnectableObservable<Integer> co = Observable.range(1, 5).replay(2, TimeUnit.SECONDS);
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        co.subscribe(ts);
+        
+        co.connect();
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void bufferTimedSelectorScheduler() {
+        Observable<Integer> co = Observable.range(1, 5)
+                .replay(new Func1<Observable<Integer>, Observable<Integer>>() { 
+                    @Override
+                    public Observable<Integer> call(Observable<Integer> t) {
+                        return t;
+                    }
+                }, 2, 2, TimeUnit.SECONDS, Schedulers.computation());
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        co.subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void bufferTimedSelectorSchedulerBadBuffer() {
+        try {
+            Observable.range(1, 5)
+                    .replay(new Func1<Observable<Integer>, Observable<Integer>>() { 
+                        @Override
+                        public Observable<Integer> call(Observable<Integer> t) {
+                            return t;
+                        }
+                    }, -99, 2, TimeUnit.SECONDS, Schedulers.computation());
+        } catch (IllegalArgumentException ex) {
+            assertEquals("bufferSize < 0", ex.getMessage());
+        }
+    }
+    
+    @Test
+    public void selectorSizeTimeDefaultScheduler() {
+        Observable<Integer> co = Observable.range(1, 5)
+                .replay(new Func1<Observable<Integer>, Observable<Integer>>() { 
+                    @Override
+                    public Observable<Integer> call(Observable<Integer> t) {
+                        return t;
+                    }
+                }, 2, 2, TimeUnit.SECONDS);
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        co.subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void selectorSizeScheduler() {
+        Observable<Integer> co = Observable.range(1, 5)
+                .replay(new Func1<Observable<Integer>, Observable<Integer>>() { 
+                    @Override
+                    public Observable<Integer> call(Observable<Integer> t) {
+                        return t;
+                    }
+                }, 2, Schedulers.computation());
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        co.subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void selectorScheduler() {
+        Observable<Integer> co = Observable.range(1, 5)
+                .replay(new Func1<Observable<Integer>, Observable<Integer>>() { 
+                    @Override
+                    public Observable<Integer> call(Observable<Integer> t) {
+                        return t;
+                    }
+                }, Schedulers.computation());
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        co.subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void timeSizeDefaultScheduler() {
+        ConnectableObservable<Integer> co = Observable.range(1, 5)
+                .replay(2, 2, TimeUnit.SECONDS);
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        co.subscribe(ts);
+        
+        co.connect();
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/internal/operators/OperatorRetryTest.java b/src/test/java/rx/internal/operators/OperatorRetryTest.java
index b461289130..0a63eca489 100644
--- a/src/test/java/rx/internal/operators/OperatorRetryTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRetryTest.java
@@ -27,9 +27,10 @@
 import org.mockito.*;
 
 import rx.*;
-import rx.Observable.OnSubscribe;
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.functions.*;
 import rx.internal.util.RxRingBuffer;
 import rx.observables.GroupedObservable;
@@ -904,4 +905,42 @@ public Observable<String> call(GroupedObservable<String, String> t1) {
         inOrder.verifyNoMoreInteractions();
     }
 
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    @Test
+    public void retryWhenDefaultScheduler() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(1)
+        .concatWith(Observable.<Integer>error(new TestException()))
+        .retryWhen((Func1)new Func1<Observable, Observable>() {
+            @Override
+            public Observable call(Observable o) {
+                return o.take(2);
+            }
+        }).subscribe(ts);
+        
+        ts.assertValues(1, 1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+    }
+    
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    @Test
+    public void retryWhenTrampolineScheduler() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(1)
+        .concatWith(Observable.<Integer>error(new TestException()))
+        .retryWhen((Func1)new Func1<Observable, Observable>() {
+            @Override
+            public Observable call(Observable o) {
+                return o.take(2);
+            }
+        }, Schedulers.trampoline()).subscribe(ts);
+        
+        ts.assertValues(1, 1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorSkipLastTest.java b/src/test/java/rx/internal/operators/OperatorSkipLastTest.java
index fb9de98ab9..23ba740026 100644
--- a/src/test/java/rx/internal/operators/OperatorSkipLastTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSkipLastTest.java
@@ -24,15 +24,18 @@
 import static org.mockito.Mockito.verify;
 
 import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
 
 import org.junit.Test;
 import org.mockito.InOrder;
 
-import rx.Observable;
-import rx.Observer;
+import rx.*;
+import rx.functions.Func1;
 import rx.internal.util.RxRingBuffer;
 import rx.observers.TestSubscriber;
-import rx.schedulers.Schedulers;
+import rx.plugins.RxJavaHooks;
+import rx.schedulers.*;
+import rx.subjects.PublishSubject;
 
 public class OperatorSkipLastTest {
 
@@ -119,4 +122,41 @@ public void testSkipLastWithNegativeCount() {
         Observable.just("one").skipLast(-1);
     }
 
+    @Test
+    public void skipLastDefaultScheduler() {
+        final TestScheduler scheduler = new TestScheduler();
+
+        RxJavaHooks.setOnComputationScheduler(new Func1<Scheduler, Scheduler>() {
+            @Override
+            public Scheduler call(Scheduler t) {
+                return scheduler;
+            }
+        });
+        
+        try {
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            PublishSubject<Integer> ps = PublishSubject.create();
+            
+            ps.skipLast(1, TimeUnit.SECONDS).subscribe(ts);
+            
+            ps.onNext(1);
+            ps.onNext(2);
+            ps.onNext(3);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+            
+            ps.onNext(4);
+            ps.onNext(5);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+            ps.onCompleted();
+            
+            ts.assertValues(1, 2, 3);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorSkipTest.java b/src/test/java/rx/internal/operators/OperatorSkipTest.java
index 21ad07b251..2fc14ad5d1 100644
--- a/src/test/java/rx/internal/operators/OperatorSkipTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSkipTest.java
@@ -29,10 +29,12 @@
 
 import org.junit.Test;
 
-import rx.Observable;
-import rx.Observer;
-import rx.functions.Action1;
+import rx.*;
+import rx.functions.*;
 import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
+import rx.schedulers.TestScheduler;
+import rx.subjects.PublishSubject;
 
 public class OperatorSkipTest {
 
@@ -177,5 +179,37 @@ public void testRequestOverflowDoesNotOccur() {
         ts.assertNoErrors();
         assertEquals(Arrays.asList(6,7,8,9,10), ts.getOnNextEvents());
     }
-    
+
+    @Test
+    public void skipDefaultScheduler() {
+        final TestScheduler scheduler = new TestScheduler();
+
+        RxJavaHooks.setOnComputationScheduler(new Func1<Scheduler, Scheduler>() {
+            @Override
+            public Scheduler call(Scheduler t) {
+                return scheduler;
+            }
+        });
+        
+        try {
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            PublishSubject<Integer> ps = PublishSubject.create();
+            
+            ps.skip(1, TimeUnit.SECONDS).subscribe(ts);
+            
+            ps.onNext(1);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+            
+            ps.onNext(2);
+            ps.onCompleted();
+            
+            ts.assertValue(2);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorTakeLastTest.java b/src/test/java/rx/internal/operators/OperatorTakeLastTest.java
index 154b3067b0..beee002ef0 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeLastTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeLastTest.java
@@ -391,4 +391,63 @@ public void nullElements() {
         ts.assertNoErrors();
     }
 
+    @Test
+    public void takeLastBuffer() {
+        TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+        
+        Observable.range(1, 5).takeLastBuffer(1).subscribe(ts);
+        
+        ts.assertValue(Arrays.asList(5));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void takeLastBufferTimed() {
+        TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+        
+        Observable.range(1, 5).takeLastBuffer(5, TimeUnit.SECONDS).subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValue(Arrays.asList(1, 2, 3, 4, 5));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void takeLastBufferTimedSized() {
+        TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+        
+        Observable.range(1, 5).takeLastBuffer(1, 5, TimeUnit.SECONDS).subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValue(Arrays.asList(5));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void takeLastBufferTimedIO() {
+        TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+        
+        Observable.range(1, 5).takeLastBuffer(5, TimeUnit.SECONDS, Schedulers.io()).subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValue(Arrays.asList(1, 2, 3, 4, 5));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void takeLastBufferTimedSizedIO() {
+        TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+        
+        Observable.range(1, 5).takeLastBuffer(1, 5, TimeUnit.SECONDS, Schedulers.io()).subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValue(Arrays.asList(5));
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
 }
diff --git a/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java b/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java
index c227339702..9889a720cc 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java
@@ -29,12 +29,12 @@
 import org.junit.*;
 import org.mockito.InOrder;
 
-import rx.Observable;
-import rx.Observer;
+import rx.*;
 import rx.Scheduler.Worker;
 import rx.exceptions.TestException;
-import rx.functions.Action0;
+import rx.functions.*;
 import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.*;
 import rx.subjects.PublishSubject;
 
@@ -284,4 +284,40 @@ public void nullElements() {
         ts.assertCompleted();
         ts.assertNoErrors();
     }
+    
+    @Test
+    public void takeLastDefaultScheduler() {
+        final TestScheduler scheduler = new TestScheduler();
+
+        RxJavaHooks.setOnComputationScheduler(new Func1<Scheduler, Scheduler>() {
+            @Override
+            public Scheduler call(Scheduler t) {
+                return scheduler;
+            }
+        });
+        
+        try {
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            PublishSubject<Integer> ps = PublishSubject.create();
+            
+            ps.takeLast(1, TimeUnit.SECONDS).subscribe(ts);
+            
+            ps.onNext(1);
+            ps.onNext(2);
+            ps.onNext(3);
+            
+            scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
+            
+            ps.onNext(4);
+            ps.onNext(5);
+            ps.onCompleted();
+            
+            ts.assertValues(4, 5);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorTakeTimedTest.java b/src/test/java/rx/internal/operators/OperatorTakeTimedTest.java
index 214e295bd6..5a718675ff 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeTimedTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeTimedTest.java
@@ -26,9 +26,11 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 
-import rx.Observable;
-import rx.Observer;
+import rx.*;
 import rx.exceptions.TestException;
+import rx.functions.Func1;
+import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -131,4 +133,42 @@ public void testTakeTimedErrorAfterTime() {
         verify(o, never()).onNext(4);
         verify(o, never()).onError(any(TestException.class));
     }
+    
+    @Test
+    public void takeDefaultScheduler() {
+        final TestScheduler scheduler = new TestScheduler();
+
+        RxJavaHooks.setOnComputationScheduler(new Func1<Scheduler, Scheduler>() {
+            @Override
+            public Scheduler call(Scheduler t) {
+                return scheduler;
+            }
+        });
+        
+        try {
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            
+            PublishSubject<Integer> ps = PublishSubject.create();
+            
+            ps.take(1, TimeUnit.SECONDS).subscribe(ts);
+            
+            ps.onNext(1);
+            ps.onNext(2);
+            ps.onNext(3);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+            
+            ps.onNext(4);
+            ps.onNext(5);
+            
+            scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+            ps.onCompleted();
+            
+            ts.assertValues(1, 2, 3);
+            ts.assertNoErrors();
+            ts.assertCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java b/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
index 0090d57546..e2f7374753 100644
--- a/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
+++ b/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
@@ -33,6 +33,7 @@
 import rx.Subscriber;
 import rx.exceptions.TestException;
 import rx.functions.Action0;
+import rx.observers.TestSubscriber;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -158,4 +159,17 @@ public void testThrottle() {
         inOrder.verify(observer).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
+    
+    @Test
+    public void timed() {
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(1, 2).throttleFirst(1, TimeUnit.SECONDS).subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorTimeIntervalTest.java b/src/test/java/rx/internal/operators/OperatorTimeIntervalTest.java
index 68c91bbd07..a1e774ed58 100644
--- a/src/test/java/rx/internal/operators/OperatorTimeIntervalTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTimeIntervalTest.java
@@ -26,8 +26,9 @@
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
-import rx.Observable;
-import rx.Observer;
+import rx.*;
+import rx.functions.Func1;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.TestScheduler;
 import rx.schedulers.TimeInterval;
 import rx.subjects.PublishSubject;
@@ -73,4 +74,41 @@ public void testTimeInterval() {
         inOrder.verify(observer, times(1)).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
+    
+    @Test
+    public void withDefaultScheduler() {
+        
+        final TestScheduler scheduler = new TestScheduler();
+
+        RxJavaHooks.setOnComputationScheduler(new Func1<Scheduler, Scheduler>() {
+            @Override
+            public Scheduler call(Scheduler t) {
+                return scheduler;
+            }
+        });
+        
+        try {
+            InOrder inOrder = inOrder(observer);
+            subject.timeInterval().subscribe(observer);
+    
+            scheduler.advanceTimeBy(1000, TIME_UNIT);
+            subject.onNext(1);
+            scheduler.advanceTimeBy(2000, TIME_UNIT);
+            subject.onNext(2);
+            scheduler.advanceTimeBy(3000, TIME_UNIT);
+            subject.onNext(3);
+            subject.onCompleted();
+    
+            inOrder.verify(observer, times(1)).onNext(
+                    new TimeInterval<Integer>(1000, 1));
+            inOrder.verify(observer, times(1)).onNext(
+                    new TimeInterval<Integer>(2000, 2));
+            inOrder.verify(observer, times(1)).onNext(
+                    new TimeInterval<Integer>(3000, 3));
+            inOrder.verify(observer, times(1)).onCompleted();
+            inOrder.verifyNoMoreInteractions();
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorTimeoutTests.java b/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
index 4c2ae8c75b..cc2284efc8 100644
--- a/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
+++ b/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
@@ -15,29 +15,19 @@
  */
 package rx.internal.operators;
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
 import java.io.IOException;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+import java.util.concurrent.*;
 
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.MockitoAnnotations;
+import org.junit.*;
+import org.mockito.*;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
+import rx.functions.Func1;
+import rx.observers.TestSubscriber;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -360,4 +350,81 @@ public void call(Subscriber<? super String> subscriber) {
 
         verify(s, times(1)).unsubscribe();
     }
+    
+    @Test
+    public void withDefaultScheduler() {
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(1).timeout(5, TimeUnit.SECONDS).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void withSelector() {
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(1).timeout(new Func1<Integer, Observable<Object>>() {
+            @Override
+            public Observable<Object> call(Integer t) {
+                return Observable.never();
+            }
+        }).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void withSelectorAndDefault() {
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(1).timeout(new Func1<Integer, Observable<Object>>() {
+            @Override
+            public Observable<Object> call(Integer t) {
+                return Observable.never();
+            }
+        }, Observable.just(2)).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void withSelectorAndDefault2() {
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(1).concatWith(
+        Observable.<Integer>never())
+        .timeout(new Func1<Integer, Observable<Object>>() {
+            @Override
+            public Observable<Object> call(Integer t) {
+                return Observable.just((Object)1);
+            }
+        }, Observable.just(2)).subscribe(ts);
+        
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void withDefaultSchedulerAndOther() {
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.just(1).timeout(5, TimeUnit.SECONDS, Observable.just(2)).subscribe(ts);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java b/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
index 51670b1b7a..b825266a10 100644
--- a/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
@@ -15,19 +15,12 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertFalse;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
@@ -35,13 +28,10 @@
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Observer;
-import rx.Subscriber;
 import rx.exceptions.TestException;
-import rx.functions.Func0;
-import rx.functions.Func1;
+import rx.functions.*;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
@@ -435,4 +425,18 @@ public void run() {
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
+    
+    @Test
+    public void selectorNull() {
+        try {
+            Observable.never().timeout(new Func0<Observable<Object>>() {
+                @Override
+                public Observable<Object> call() {
+                    return Observable.never();
+                }
+            }, null, Observable.empty());
+        } catch (NullPointerException ex) {
+            assertEquals("timeoutSelector is null", ex.getMessage());
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorTimestampTest.java b/src/test/java/rx/internal/operators/OperatorTimestampTest.java
index bf39ae299a..9dd01597fd 100644
--- a/src/test/java/rx/internal/operators/OperatorTimestampTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTimestampTest.java
@@ -16,23 +16,17 @@
 package rx.internal.operators;
 
 import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
 
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.junit.*;
+import org.mockito.*;
 
-import rx.Observable;
-import rx.Observer;
-import rx.schedulers.TestScheduler;
-import rx.schedulers.Timestamped;
+import rx.*;
+import rx.functions.Func1;
+import rx.plugins.RxJavaHooks;
+import rx.schedulers.*;
 import rx.subjects.PublishSubject;
 
 public class OperatorTimestampTest {
@@ -91,4 +85,39 @@ public void timestampWithScheduler2() {
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
     }
+    
+    @Test
+    public void withDefaultScheduler() {
+        final TestScheduler scheduler = new TestScheduler();
+
+        RxJavaHooks.setOnComputationScheduler(new Func1<Scheduler, Scheduler>() {
+            @Override
+            public Scheduler call(Scheduler t) {
+                return scheduler;
+            }
+        });
+        
+        try {
+            PublishSubject<Integer> source = PublishSubject.create();
+            Observable<Timestamped<Integer>> m = source.timestamp();
+            m.subscribe(observer);
+    
+            source.onNext(1);
+            scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+            source.onNext(2);
+            scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+            source.onNext(3);
+    
+            InOrder inOrder = inOrder(observer);
+    
+            inOrder.verify(observer, times(1)).onNext(new Timestamped<Integer>(0, 1));
+            inOrder.verify(observer, times(1)).onNext(new Timestamped<Integer>(100, 2));
+            inOrder.verify(observer, times(1)).onNext(new Timestamped<Integer>(200, 3));
+    
+            verify(observer, never()).onError(any(Throwable.class));
+            verify(observer, never()).onCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
index f687fb2b28..f89d7d640b 100644
--- a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
+++ b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
@@ -148,4 +148,53 @@ static void await(CyclicBarrier cb) {
             ex.printStackTrace();
         }
     }
+    
+    @Test
+    public void testSortedListCapacity() {
+        Observable<Integer> w = Observable.just(1, 3, 2, 5, 4);
+        Observable<List<Integer>> observable = w.toSortedList(4);
+
+        @SuppressWarnings("unchecked")
+        Observer<List<Integer>> observer = mock(Observer.class);
+        observable.subscribe(observer);
+        verify(observer, times(1)).onNext(Arrays.asList(1, 2, 3, 4, 5));
+        verify(observer, Mockito.never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+    
+    @Test
+    public void testSortedCustomComparer() {
+        Observable<Integer> w = Observable.just(1, 3, 2, 5, 4);
+        Observable<List<Integer>> observable = w.toSortedList(new Func2<Integer, Integer, Integer>() {
+            @Override
+            public Integer call(Integer t1, Integer t2) {
+                return t2.compareTo(t1);
+            }
+        });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<Integer>> observer = mock(Observer.class);
+        observable.subscribe(observer);
+        verify(observer, times(1)).onNext(Arrays.asList(5, 4, 3, 2, 1));
+        verify(observer, Mockito.never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+    
+    @Test
+    public void testSortedCustomComparerHinted() {
+        Observable<Integer> w = Observable.just(1, 3, 2, 5, 4);
+        Observable<List<Integer>> observable = w.toSortedList(new Func2<Integer, Integer, Integer>() {
+            @Override
+            public Integer call(Integer t1, Integer t2) {
+                return t2.compareTo(t1);
+            }
+        }, 4);
+
+        @SuppressWarnings("unchecked")
+        Observer<List<Integer>> observer = mock(Observer.class);
+        observable.subscribe(observer);
+        verify(observer, times(1)).onNext(Arrays.asList(5, 4, 3, 2, 1));
+        verify(observer, Mockito.never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java b/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java
index 34c3739c88..a5c41cfc02 100644
--- a/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java
@@ -192,5 +192,42 @@ public Observable<Integer> call(Observable<Integer> w) {
         ts.assertCompleted();
         Assert.assertFalse(ts.getOnNextEvents().isEmpty());
     }
+
+    @Test
+    public void timeCountDefaultScheduler() {
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(1, 10).window(5, TimeUnit.SECONDS, 5)
+        .flatMap(new Func1<Observable<Integer>, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Observable<Integer> w) {
+                return w;
+            }
+        }).subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValueCount(10);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
     
+    @Test
+    public void spanSkipDefaultScheduler() {
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        Observable.range(1, 10).window(5, 5, TimeUnit.SECONDS)
+        .flatMap(new Func1<Observable<Integer>, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Observable<Integer> w) {
+                return w;
+            }
+        }).subscribe(ts);
+        
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+        ts.assertValueCount(10);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorZipTest.java b/src/test/java/rx/internal/operators/OperatorZipTest.java
index 7dd255b1f9..5bc901bcc6 100644
--- a/src/test/java/rx/internal/operators/OperatorZipTest.java
+++ b/src/test/java/rx/internal/operators/OperatorZipTest.java
@@ -15,44 +15,22 @@
  */
 package rx.internal.operators;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.NoSuchElementException;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
 
-import org.junit.Assert;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
 
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.*;
 import org.mockito.InOrder;
 
-import rx.Notification;
+import rx.*;
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action1;
-import rx.functions.Func2;
-import rx.functions.Func3;
-import rx.functions.FuncN;
-import rx.functions.Functions;
+import rx.functions.*;
 import rx.internal.util.RxRingBuffer;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
@@ -1401,4 +1379,119 @@ public Integer call(Object... a) {
         sub1.assertNoErrors();
         sub1.assertCompleted();
     }
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void zip4() {
+        TestSubscriber<String> ts = TestSubscriber.create();
+        Observable<Integer> source = Observable.just(1);
+        
+        Observable.zip(source, source, source, source, new Func4() {
+            @Override
+            public Object call(Object t1, Object t2, Object t3, Object t4) {
+                return "" + t1 + t2 + t3 + t4;
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue("1111");
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void zip5() {
+        TestSubscriber<String> ts = TestSubscriber.create();
+        Observable<Integer> source = Observable.just(1);
+        
+        Observable.zip(source, source, source, source, source, new Func5() {
+            @Override
+            public Object call(Object t1, Object t2, Object t3, Object t4, Object t5) {
+                return "" + t1 + t2 + t3 + t4 + t5;
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue("11111");
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void zip6() {
+        TestSubscriber<String> ts = TestSubscriber.create();
+        Observable<Integer> source = Observable.just(1);
+        
+        Observable.zip(source, source, source, source, source, source, new Func6() {
+            @Override
+            public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6) {
+                return "" + t1 + t2 + t3 + t4 + t5 + t6;
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue("111111");
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void zip7() {
+        TestSubscriber<String> ts = TestSubscriber.create();
+        Observable<Integer> source = Observable.just(1);
+        
+        Observable.zip(source, source, source, source, source, source, source, new Func7() {
+            @Override
+            public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7) {
+                return "" + t1 + t2 + t3 + t4 + t5 + t6 + t7;
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue("1111111");
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void zip8() {
+        TestSubscriber<String> ts = TestSubscriber.create();
+        Observable<Integer> source = Observable.just(1);
+        
+        Observable.zip(source, source, source, source, source, source, source, source, new Func8() {
+            @Override
+            public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7, Object t8) {
+                return "" + t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8;
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue("11111111");
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Test
+    public void zip9() {
+        TestSubscriber<String> ts = TestSubscriber.create();
+        Observable<Integer> source = Observable.just(1);
+        
+        Observable.zip(source, source, source, source, source, source, source, source, source, new Func9() {
+            @Override
+            public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, 
+                    Object t6, Object t7, Object t8, Object t9) {
+                return "" + t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8 + t9;
+            }
+        })
+        .subscribe(ts);
+        
+        ts.assertValue("111111111");
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }
diff --git a/src/test/java/rx/observables/AsyncOnSubscribeTest.java b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
index 71370e84f3..a707757e2d 100644
--- a/src/test/java/rx/observables/AsyncOnSubscribeTest.java
+++ b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
@@ -60,7 +60,7 @@ public void setup() {
     @Test
     public void testSerializesConcurrentObservables() throws InterruptedException {
         final TestScheduler scheduler = new TestScheduler();
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        AsyncOnSubscribe<Integer, Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
             @Override
             public Integer call() {
                 return 1;
diff --git a/src/test/java/rx/schedulers/SchedulerTests.java b/src/test/java/rx/schedulers/SchedulerTests.java
index c07d3078f2..bc929d1bef 100644
--- a/src/test/java/rx/schedulers/SchedulerTests.java
+++ b/src/test/java/rx/schedulers/SchedulerTests.java
@@ -117,12 +117,12 @@ public static void testHandledErrorIsNotDeliveredToThreadHandler(Scheduler sched
 
     public static void testCancelledRetention(Scheduler.Worker w, boolean periodic) throws InterruptedException {
         System.out.println("Wait before GC");
-        Thread.sleep(1000);
+        Thread.sleep(500);
 
         System.out.println("GC");
         System.gc();
 
-        Thread.sleep(1000);
+        Thread.sleep(500);
 
 
         MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
@@ -131,7 +131,7 @@ public static void testCancelledRetention(Scheduler.Worker w, boolean periodic)
 
         System.out.printf("Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
 
-        int n = 500 * 1000;
+        int n = 100 * 1000;
         if (periodic) {
             final CountDownLatch cdl = new CountDownLatch(n);
             final Action0 action = new Action0() {
@@ -165,12 +165,12 @@ public void call() {
         w.unsubscribe();
 
         System.out.println("Wait before second GC");
-        Thread.sleep(NewThreadWorker.PURGE_FREQUENCY + 2000);
+        Thread.sleep(NewThreadWorker.PURGE_FREQUENCY + 1000);
 
         System.out.println("Second GC");
         System.gc();
 
-        Thread.sleep(1000);
+        Thread.sleep(500);
 
         memHeap = memoryMXBean.getHeapMemoryUsage();
         long finish = memHeap.getUsed();

From f3777dfd04ba1817a2923648346caa1f09aa3f28 Mon Sep 17 00:00:00 2001
From: George Campbell <abersnaze@gmail.com>
Date: Thu, 30 Jun 2016 09:57:04 -0700
Subject: [PATCH 098/263] =?UTF-8?q?Ability=20to=20create=20custom=20schedu?=
 =?UTF-8?q?lers=20with=20behavior=20based=20on=20composing=20operators.=20?=
 =?UTF-8?q?=E2=80=A2=20made=20it=20private=20and=20added=20a=20instance=20?=
 =?UTF-8?q?method=20to=20Scheduler.=20=E2=80=A2=20rewrote=20the=20test=20t?=
 =?UTF-8?q?o=20get=20a=20little=20more=20coverage.=20=E2=80=A2=20wrapping?=
 =?UTF-8?q?=20each=20of=20the=20onNext/onCompleted=20to=20ensure=20no=20ov?=
 =?UTF-8?q?erlapping=20calls=20=E2=80=A2=20Break=20up=20the=20Worker=20as?=
 =?UTF-8?q?=20Completable=20into=20Worker=20as=20Observable.=20Now=20the?=
 =?UTF-8?q?=20schedules=20actions=20are=20the=20indivisible=20elements=20t?=
 =?UTF-8?q?hat=20are=20subscribed=20to.=20The=20user=20has=20additional=20?=
 =?UTF-8?q?choice=20at=20the=20cost=20of=20making=20the=20API=20more=20com?=
 =?UTF-8?q?plicated.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/rx/Scheduler.java               |  78 +++++
 .../rx/internal/schedulers/SchedulerWhen.java | 302 ++++++++++++++++++
 .../java/rx/schedulers/SchedulerWhenTest.java | 206 ++++++++++++
 3 files changed, 586 insertions(+)
 create mode 100644 src/main/java/rx/internal/schedulers/SchedulerWhen.java
 create mode 100644 src/test/java/rx/schedulers/SchedulerWhenTest.java

diff --git a/src/main/java/rx/Scheduler.java b/src/main/java/rx/Scheduler.java
index 8437396e56..f1b8a0e28a 100644
--- a/src/main/java/rx/Scheduler.java
+++ b/src/main/java/rx/Scheduler.java
@@ -17,7 +17,10 @@
 
 import java.util.concurrent.TimeUnit;
 
+import rx.annotations.Experimental;
 import rx.functions.Action0;
+import rx.functions.Func1;
+import rx.internal.schedulers.SchedulerWhen;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.MultipleAssignmentSubscription;
 
@@ -182,4 +185,79 @@ public long now() {
         return System.currentTimeMillis();
     }
 
+	/**
+	 * Allows the use of operators for controlling the timing around when
+	 * actions scheduled on workers are actually done. This makes it possible to
+	 * layer additional behavior on this {@link Scheduler}. The only parameter
+	 * is a function that flattens an {@link Observable} of {@link Observable}
+	 * of {@link Completable}s into just one {@link Completable}. There must be
+	 * a chain of operators connecting the returned value to the source
+	 * {@link Observable} otherwise any work scheduled on the returned
+	 * {@link Scheduler} will not be executed.
+	 * <p>
+	 * When {@link Scheduler#createWorker()} is invoked a {@link Observable} of
+	 * {@link Completable}s is onNext'd to the combinator to be flattened. If
+	 * the inner {@link Observable} is not immediately subscribed to an calls to
+	 * {@link Worker#schedule} are buffered. Once the {@link Observable} is
+	 * subscribed to actions are then onNext'd as {@link Completable}s.
+	 * <p>
+	 * Finally the actions scheduled on the parent {@link Scheduler} when the
+	 * inner most {@link Completable}s are subscribed to.
+	 * <p>
+	 * When the {@link Worker} is unsubscribed the {@link Completable} emits an
+	 * onComplete and triggers any behavior in the flattening operator. The
+	 * {@link Observable} and all {@link Completable}s give to the flattening
+	 * function never onError.
+	 * <p>
+	 * Limit the amount concurrency two at a time without creating a new fix
+	 * size thread pool:
+	 * 
+	 * <pre>
+	 * Scheduler limitSched = Schedulers.computation().when(workers -> {
+	 * 	// use merge max concurrent to limit the number of concurrent
+	 * 	// callbacks two at a time
+	 * 	return Completable.merge(Observable.merge(workers), 2);
+	 * });
+	 * </pre>
+	 * <p>
+	 * This is a slightly different way to limit the concurrency but it has some
+	 * interesting benefits and drawbacks to the method above. It works by
+	 * limited the number of concurrent {@link Worker}s rather than individual
+	 * actions. Generally each {@link Observable} uses its own {@link Worker}.
+	 * This means that this will essentially limit the number of concurrent
+	 * subscribes. The danger comes from using operators like
+	 * {@link Observable#zip(Observable, Observable, rx.functions.Func2)} where
+	 * subscribing to the first {@link Observable} could deadlock the
+	 * subscription to the second.
+	 * 
+	 * <pre>
+	 * Scheduler limitSched = Schedulers.computation().when(workers -> {
+	 * 	// use merge max concurrent to limit the number of concurrent
+	 * 	// Observables two at a time
+	 * 	return Completable.merge(Observable.merge(workers, 2));
+	 * });
+	 * </pre>
+	 * 
+	 * Slowing down the rate to no more than than 1 a second. This suffers from
+	 * the same problem as the one above I could find an {@link Observable}
+	 * operator that limits the rate without dropping the values (aka leaky
+	 * bucket algorithm).
+	 * 
+	 * <pre>
+	 * Scheduler slowSched = Schedulers.computation().when(workers -> {
+	 * 	// use concatenate to make each worker happen one at a time.
+	 * 	return Completable.concat(workers.map(actions -> {
+	 * 		// delay the starting of the next worker by 1 second.
+	 * 		return Completable.merge(actions.delaySubscription(1, TimeUnit.SECONDS));
+	 * 	}));
+	 * });
+	 * </pre>
+	 * 
+	 * @param combine
+	 * @return
+	 */
+    @Experimental
+	public <S extends Scheduler & Subscription> S when(Func1<Observable<Observable<Completable>>, Completable> combine) {
+		return (S) new SchedulerWhen(combine, this);
+	}
 }
diff --git a/src/main/java/rx/internal/schedulers/SchedulerWhen.java b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
new file mode 100644
index 0000000000..b1312a458b
--- /dev/null
+++ b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
@@ -0,0 +1,302 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.schedulers;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import rx.Completable;
+import rx.Completable.CompletableOnSubscribe;
+import rx.Completable.CompletableSubscriber;
+import rx.Scheduler.Worker;
+import rx.Observable;
+import rx.Observer;
+import rx.Scheduler;
+import rx.Subscription;
+import rx.annotations.Experimental;
+import rx.functions.Action0;
+import rx.functions.Func1;
+import rx.internal.operators.BufferUntilSubscriber;
+import rx.observers.SerializedObserver;
+import rx.subjects.PublishSubject;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * Allows the use of operators for controlling the timing around when actions
+ * scheduled on workers are actually done. This makes it possible to layer
+ * additional behavior on this {@link Scheduler}. The only parameter is a
+ * function that flattens an {@link Observable} of {@link Observable} of
+ * {@link Completable}s into just one {@link Completable}. There must be a chain
+ * of operators connecting the returned value to the source {@link Observable}
+ * otherwise any work scheduled on the returned {@link Scheduler} will not be
+ * executed.
+ * <p>
+ * When {@link Scheduler#createWorker()} is invoked a {@link Observable} of
+ * {@link Completable}s is onNext'd to the combinator to be flattened. If the
+ * inner {@link Observable} is not immediately subscribed to an calls to
+ * {@link Worker#schedule} are buffered. Once the {@link Observable} is
+ * subscribed to actions are then onNext'd as {@link Completable}s.
+ * <p>
+ * Finally the actions scheduled on the parent {@link Scheduler} when the inner
+ * most {@link Completable}s are subscribed to.
+ * <p>
+ * When the {@link Worker} is unsubscribed the {@link Completable} emits an
+ * onComplete and triggers any behavior in the flattening operator. The
+ * {@link Observable} and all {@link Completable}s give to the flattening
+ * function never onError.
+ * <p>
+ * Limit the amount concurrency two at a time without creating a new fix size
+ * thread pool:
+ * 
+ * <pre>
+ * Scheduler limitSched = Schedulers.computation().when(workers -> {
+ * 	// use merge max concurrent to limit the number of concurrent
+ * 	// callbacks two at a time
+ * 	return Completable.merge(Observable.merge(workers), 2);
+ * });
+ * </pre>
+ * <p>
+ * This is a slightly different way to limit the concurrency but it has some
+ * interesting benefits and drawbacks to the method above. It works by limited
+ * the number of concurrent {@link Worker}s rather than individual actions.
+ * Generally each {@link Observable} uses its own {@link Worker}. This means
+ * that this will essentially limit the number of concurrent subscribes. The
+ * danger comes from using operators like
+ * {@link Observable#zip(Observable, Observable, rx.functions.Func2)} where
+ * subscribing to the first {@link Observable} could deadlock the subscription
+ * to the second.
+ * 
+ * <pre>
+ * Scheduler limitSched = Schedulers.computation().when(workers -> {
+ * 	// use merge max concurrent to limit the number of concurrent
+ * 	// Observables two at a time
+ * 	return Completable.merge(Observable.merge(workers, 2));
+ * });
+ * </pre>
+ * 
+ * Slowing down the rate to no more than than 1 a second. This suffers from the
+ * same problem as the one above I could find an {@link Observable} operator
+ * that limits the rate without dropping the values (aka leaky bucket
+ * algorithm).
+ * 
+ * <pre>
+ * Scheduler slowSched = Schedulers.computation().when(workers -> {
+ * 	// use concatenate to make each worker happen one at a time.
+ * 	return Completable.concat(workers.map(actions -> {
+ * 		// delay the starting of the next worker by 1 second.
+ * 		return Completable.merge(actions.delaySubscription(1, TimeUnit.SECONDS));
+ * 	}));
+ * });
+ * </pre>
+ * 
+ * @param combine
+ * @return
+ */
+@Experimental
+public class SchedulerWhen extends Scheduler implements Subscription {
+	private final Scheduler actualScheduler;
+	private final Observer<Observable<Completable>> workerObserver;
+	private final Subscription subscription;
+
+	public SchedulerWhen(Func1<Observable<Observable<Completable>>, Completable> combine, Scheduler actualScheduler) {
+		this.actualScheduler = actualScheduler;
+		// workers are converted into completables and put in this queue.
+		PublishSubject<Observable<Completable>> workerSubject = PublishSubject.create();
+		this.workerObserver = new SerializedObserver<Observable<Completable>>(workerSubject);
+		// send it to a custom combinator to pick the order and rate at which
+		// workers are processed.
+		this.subscription = combine.call(workerSubject.onBackpressureBuffer()).subscribe();
+	}
+
+	@Override
+	public void unsubscribe() {
+		subscription.unsubscribe();
+	}
+
+	@Override
+	public boolean isUnsubscribed() {
+		return subscription.isUnsubscribed();
+	}
+
+	@Override
+	public Worker createWorker() {
+		final Worker actualWorker = actualScheduler.createWorker();
+		// a queue for the actions submitted while worker is waiting to get to
+		// the subscribe to off the workerQueue.
+		BufferUntilSubscriber<ScheduledAction> actionSubject = BufferUntilSubscriber.<ScheduledAction>create();
+		final Observer<ScheduledAction> actionObserver = new SerializedObserver<ScheduledAction>(actionSubject);
+		// convert the work of scheduling all the actions into a completable
+		Observable<Completable> actions = actionSubject.map(new Func1<ScheduledAction, Completable>() {
+			@Override
+			public Completable call(final ScheduledAction action) {
+				return Completable.create(new CompletableOnSubscribe() {
+					@Override
+					public void call(CompletableSubscriber actionCompletable) {
+						actionCompletable.onSubscribe(action);
+						action.call(actualWorker);
+						actionCompletable.onCompleted();
+					}
+				});
+			}
+		});
+
+		// a worker that queues the action to the actionQueue subject.
+		Worker worker = new Worker() {
+			private final AtomicBoolean unsubscribed = new AtomicBoolean();
+
+			@Override
+			public void unsubscribe() {
+				// complete the actionQueue when worker is unsubscribed to make
+				// room for the next worker in the workerQueue.
+				if (unsubscribed.compareAndSet(false, true)) {
+					actualWorker.unsubscribe();
+					actionObserver.onCompleted();
+				}
+			}
+
+			@Override
+			public boolean isUnsubscribed() {
+				return unsubscribed.get();
+			}
+
+			@Override
+			public Subscription schedule(final Action0 action, final long delayTime, final TimeUnit unit) {
+				// send a scheduled action to the actionQueue
+				DelayedAction delayedAction = new DelayedAction(action, delayTime, unit);
+				actionObserver.onNext(delayedAction);
+				return delayedAction;
+			}
+
+			@Override
+			public Subscription schedule(final Action0 action) {
+				// send a scheduled action to the actionQueue
+				ImmediateAction immediateAction = new ImmediateAction(action);
+				actionObserver.onNext(immediateAction);
+				return immediateAction;
+			}
+		};
+
+		// enqueue the completable that process actions put in reply subject
+		workerObserver.onNext(actions);
+
+		// return the worker that adds actions to the reply subject
+		return worker;
+	}
+
+	private static final Subscription SUBSCRIBED = new Subscription() {
+		@Override
+		public void unsubscribe() {
+		}
+
+		@Override
+		public boolean isUnsubscribed() {
+			return false;
+		}
+	};
+
+	private static final Subscription UNSUBSCRIBED = Subscriptions.unsubscribed();
+
+	@SuppressWarnings("serial")
+	private static abstract class ScheduledAction extends AtomicReference<Subscription> implements Subscription {
+		public ScheduledAction() {
+			super(SUBSCRIBED);
+		}
+
+		private final void call(Worker actualWorker) {
+			Subscription oldState = get();
+			// either SUBSCRIBED or UNSUBSCRIBED
+			if (oldState == UNSUBSCRIBED) {
+				// no need to schedule return
+				return;
+			}
+			if (oldState != SUBSCRIBED) {
+				// has already been scheduled return
+				// should not be able to get here but handle it anyway by not
+				// rescheduling.
+				return;
+			}
+
+			Subscription newState = callActual(actualWorker);
+
+			if (!compareAndSet(SUBSCRIBED, newState)) {
+				// set would only fail if the new current state is some other
+				// subscription from a concurrent call to this method.
+				// Unsubscribe from the action just scheduled because it lost
+				// the race.
+				newState.unsubscribe();
+			}
+		}
+
+		protected abstract Subscription callActual(Worker actualWorker);
+
+		@Override
+		public boolean isUnsubscribed() {
+			return get().isUnsubscribed();
+		}
+
+		@Override
+		public void unsubscribe() {
+			Subscription oldState;
+			// no matter what the current state is the new state is going to be
+			Subscription newState = UNSUBSCRIBED;
+			do {
+				oldState = get();
+				if (oldState == UNSUBSCRIBED) {
+					// the action has already been unsubscribed
+					return;
+				}
+			} while (!compareAndSet(oldState, newState));
+
+			if (oldState != SUBSCRIBED) {
+				// the action was scheduled. stop it.
+				oldState.unsubscribe();
+			}
+		}
+	}
+
+	@SuppressWarnings("serial")
+	private static class ImmediateAction extends ScheduledAction {
+		private final Action0 action;
+
+		public ImmediateAction(Action0 action) {
+			this.action = action;
+		}
+
+		@Override
+		protected Subscription callActual(Worker actualWorker) {
+			return actualWorker.schedule(action);
+		}
+	}
+
+	@SuppressWarnings("serial")
+	private static class DelayedAction extends ScheduledAction {
+		private final Action0 action;
+		private final long delayTime;
+		private final TimeUnit unit;
+
+		public DelayedAction(Action0 action, long delayTime, TimeUnit unit) {
+			this.action = action;
+			this.delayTime = delayTime;
+			this.unit = unit;
+		}
+
+		@Override
+		protected Subscription callActual(Worker actualWorker) {
+			return actualWorker.schedule(action, delayTime, unit);
+		}
+	}
+}
diff --git a/src/test/java/rx/schedulers/SchedulerWhenTest.java b/src/test/java/rx/schedulers/SchedulerWhenTest.java
new file mode 100644
index 0000000000..f911e0d10a
--- /dev/null
+++ b/src/test/java/rx/schedulers/SchedulerWhenTest.java
@@ -0,0 +1,206 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.schedulers;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import org.junit.Test;
+
+import rx.Completable;
+import rx.Observable;
+import rx.Scheduler;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.internal.schedulers.SchedulerWhen;
+import rx.observers.TestSubscriber;
+
+public class SchedulerWhenTest {
+	@Test
+	public void testAsyncMaxConcurrent() {
+		TestScheduler tSched = new TestScheduler();
+		SchedulerWhen sched = maxConcurrentScheduler(tSched);
+		TestSubscriber<Long> tSub = TestSubscriber.create();
+
+		asyncWork(sched).subscribe(tSub);
+
+		tSub.assertValueCount(0);
+
+		tSched.advanceTimeBy(0, SECONDS);
+		tSub.assertValueCount(0);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(2);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(4);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(5);
+		tSub.assertCompleted();
+		
+		sched.unsubscribe();
+	}
+
+	@Test
+	public void testAsyncDelaySubscription() {
+		final TestScheduler tSched = new TestScheduler();
+		SchedulerWhen sched = throttleScheduler(tSched);
+		TestSubscriber<Long> tSub = TestSubscriber.create();
+
+		asyncWork(sched).subscribe(tSub);
+
+		tSub.assertValueCount(0);
+
+		tSched.advanceTimeBy(0, SECONDS);
+		tSub.assertValueCount(0);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(1);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(1);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(2);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(2);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(3);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(3);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(4);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(4);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(5);
+		tSub.assertCompleted();
+		
+		sched.unsubscribe();
+	}
+
+	@Test
+	public void testSyncMaxConcurrent() {
+		TestScheduler tSched = new TestScheduler();
+		SchedulerWhen sched = maxConcurrentScheduler(tSched);
+		TestSubscriber<Long> tSub = TestSubscriber.create();
+
+		syncWork(sched).subscribe(tSub);
+
+		tSub.assertValueCount(0);
+		tSched.advanceTimeBy(0, SECONDS);
+
+		// since all the work is synchronous nothing is blocked and its all done
+		tSub.assertValueCount(5);
+		tSub.assertCompleted();
+		
+		sched.unsubscribe();
+	}
+
+	@Test
+	public void testSyncDelaySubscription() {
+		final TestScheduler tSched = new TestScheduler();
+		SchedulerWhen sched = throttleScheduler(tSched);
+		TestSubscriber<Long> tSub = TestSubscriber.create();
+
+		syncWork(sched).subscribe(tSub);
+
+		tSub.assertValueCount(0);
+
+		tSched.advanceTimeBy(0, SECONDS);
+		tSub.assertValueCount(1);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(2);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(3);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(4);
+
+		tSched.advanceTimeBy(1, SECONDS);
+		tSub.assertValueCount(5);
+		tSub.assertCompleted();
+		
+		sched.unsubscribe();
+	}
+
+	private Observable<Long> asyncWork(final Scheduler sched) {
+		return Observable.range(1, 5).flatMap(new Func1<Integer, Observable<Long>>() {
+			@Override
+			public Observable<Long> call(Integer t) {
+				return Observable.timer(1, SECONDS, sched);
+			}
+		});
+	}
+
+	private Observable<Long> syncWork(final Scheduler sched) {
+		return Observable.range(1, 5).flatMap(new Func1<Integer, Observable<Long>>() {
+			@Override
+			public Observable<Long> call(Integer t) {
+				return Observable.defer(new Func0<Observable<Long>>() {
+					@Override
+					public Observable<Long> call() {
+						return Observable.just(0l);
+					}
+				}).subscribeOn(sched);
+			}
+		});
+	}
+
+	private SchedulerWhen maxConcurrentScheduler(TestScheduler tSched) {
+		SchedulerWhen sched = new SchedulerWhen(new Func1<Observable<Observable<Completable>>, Completable>() {
+			@Override
+			public Completable call(Observable<Observable<Completable>> workerActions) {
+				Observable<Completable> workers = workerActions.map(new Func1<Observable<Completable>, Completable>() {
+					@Override
+					public Completable call(Observable<Completable> actions) {
+						return Completable.concat(actions);
+					}
+				});
+				return Completable.merge(workers, 2);
+			}
+		}, tSched);
+		return sched;
+	}
+
+	private SchedulerWhen throttleScheduler(final TestScheduler tSched) {
+		SchedulerWhen sched = new SchedulerWhen(new Func1<Observable<Observable<Completable>>, Completable>() {
+			@Override
+			public Completable call(Observable<Observable<Completable>> workerActions) {
+				Observable<Completable> workers = workerActions.map(new Func1<Observable<Completable>, Completable>() {
+					@Override
+					public Completable call(Observable<Completable> actions) {
+						return Completable.concat(actions);
+					}
+				});
+				return Completable.concat(workers.map(new Func1<Completable, Completable>() {
+					public Completable call(Completable worker) {
+						return worker.delay(1, SECONDS, tSched);
+					}
+				}));
+			}
+		}, tSched);
+		return sched;
+	}
+}

From 1354c3483a56c8a58f29956a13b3821111bf1bf8 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 9 Jul 2016 09:46:02 +0200
Subject: [PATCH 099/263] 1.x: change test heap size to avoid 137 (#4180)

* 1.x: increase test heap to 3GB

* Try with less memory plus avoid a deadlock

* Increase timeout for JCTools tests
---
 build.gradle                                              | 2 +-
 .../internal/operators/DeferredScalarSubscriberTest.java  | 4 ++--
 src/test/java/rx/internal/util/JCToolsQueueTests.java     | 8 ++++----
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/build.gradle b/build.gradle
index b83de64585..0fdeaa4a96 100644
--- a/build.gradle
+++ b/build.gradle
@@ -61,7 +61,7 @@ if (project.hasProperty('release.useLastTag')) {
 }
 
 test{
-     maxHeapSize = "2g"
+     maxHeapSize = "1500m"
 }
 
 license {
diff --git a/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java b/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
index f1aab5c286..0b91189222 100644
--- a/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
+++ b/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
@@ -341,8 +341,8 @@ public void call() {
     
     @Test
     public void emissionRequestRace2() {
-        Worker w = Schedulers.computation().createWorker();
-        Worker w2 = Schedulers.computation().createWorker();
+        Worker w = Schedulers.io().createWorker();
+        Worker w2 = Schedulers.io().createWorker();
         try {
             for (int i = 0; i < 10000; i++) {
     
diff --git a/src/test/java/rx/internal/util/JCToolsQueueTests.java b/src/test/java/rx/internal/util/JCToolsQueueTests.java
index a9f845b772..7f554993ab 100644
--- a/src/test/java/rx/internal/util/JCToolsQueueTests.java
+++ b/src/test/java/rx/internal/util/JCToolsQueueTests.java
@@ -132,7 +132,7 @@ public void testMpscLinkedAtomicQueueOfferPoll() {
         testOfferPoll(q);
     }
     
-    @Test(timeout = 2000)
+    @Test(timeout = 20000)
     public void testMpscLinkedAtomicQueuePipelined() throws InterruptedException {
         final MpscLinkedAtomicQueue<Integer> q = new MpscLinkedAtomicQueue<Integer>();
         
@@ -202,7 +202,7 @@ public void testMpscLinkedQueueOfferPoll() {
         
         testOfferPoll(q);
     }
-    @Test(timeout = 2000)
+    @Test(timeout = 20000)
     public void testMpscLinkedQueuePipelined() throws InterruptedException {
         if (!UnsafeAccess.isUnsafeAvailable()) {
             return;
@@ -356,7 +356,7 @@ public void testSpscLinkedAtomicQueueOfferPoll() {
         testOfferPoll(q);
     }
     
-    @Test(timeout = 2000)
+    @Test(timeout = 20000)
     public void testSpscLinkedAtomicQueuePipelined() throws InterruptedException {
         final SpscLinkedAtomicQueue<Integer> q = new SpscLinkedAtomicQueue<Integer>();
         final AtomicInteger count = new AtomicInteger();
@@ -411,7 +411,7 @@ public void testSpscLinkedQueueOfferPoll() {
         testOfferPoll(q);
     }
     
-    @Test(timeout = 2000)
+    @Test(timeout = 20000)
     public void testSpscLinkedQueuePipelined() throws InterruptedException {
         if (!UnsafeAccess.isUnsafeAvailable()) {
             return;

From 5e59bcf5ddc993ba6c7ab5dd29c7d8bad639a9a6 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 9 Jul 2016 22:02:25 +0200
Subject: [PATCH 100/263] 1.x: no need to run gradle assembe by travis (#4183)

* 1.x: no need to run gradle assembe by travis

* Also update the sh with the parameter

* +git fsck

* full check

* limit clone depth

* Limit memory even further

* disable PMD
---
 .travis.yml              |  6 ++++
 build.gradle             | 70 ++++++++++++++++++++--------------------
 gradle/buildViaTravis.sh |  6 ++--
 3 files changed, 45 insertions(+), 37 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 7a9db57ab4..aa7f0cee15 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,6 +4,12 @@ jdk:
 sudo: false
 # as per http://blog.travis-ci.com/2014-12-17-faster-builds-with-container-based-infrastructure/
 
+git:
+  depth: 10
+
+# prevent travis running gradle assemble; let the build script do it anyway
+install: true
+
 # script for build and release via Travis to Bintray
 script: gradle/buildViaTravis.sh
 
diff --git a/build.gradle b/build.gradle
index 0fdeaa4a96..570ceb242f 100644
--- a/build.gradle
+++ b/build.gradle
@@ -11,7 +11,7 @@ buildscript {
 description = 'RxJava: Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.'
 
 apply plugin: 'java'
-apply plugin: 'pmd'
+//apply plugin: 'pmd'
 apply plugin: 'findbugs'
 apply plugin: 'jacoco'
 apply plugin: 'ru.vyarus.animalsniffer'
@@ -61,7 +61,7 @@ if (project.hasProperty('release.useLastTag')) {
 }
 
 test{
-     maxHeapSize = "1500m"
+     maxHeapSize = "1200m"
 }
 
 license {
@@ -81,40 +81,40 @@ jacocoTestReport {
 
 build.dependsOn jacocoTestReport
 
-pmd {
-    toolVersion = '5.4.2'
-    ignoreFailures = true
-    sourceSets = [sourceSets.main]
-    ruleSets = []
-    ruleSetFiles = files('pmd.xml')
-
-}
-
-pmdMain {
-    reports {
-        html.enabled = true
-        xml.enabled = true
-    }
-}
-
-task pmdPrint(dependsOn: 'pmdMain') << {
-    File file = new File('build/reports/pmd/main.xml')
-    if (file.exists()) {
-
-        println("Listing first 100 PMD violations")
-
-        file.eachLine { line, count ->
-            if (count <= 100) {
-               println(line)
-            }
-        }
-
-    } else {
-        println("PMD file not found.")
-    }
-}
 
-build.dependsOn pmdPrint
+//pmd {
+//    toolVersion = '5.4.2'
+//    ignoreFailures = true
+//    sourceSets = [sourceSets.main]
+//    ruleSets = []
+//    ruleSetFiles = files('pmd.xml')
+//}
+
+//pmdMain {
+//    reports {
+//        html.enabled = true
+//        xml.enabled = true
+//    }
+//}
+
+//task pmdPrint(dependsOn: 'pmdMain') << {
+//    File file = new File('build/reports/pmd/main.xml')
+//    if (file.exists()) {
+//
+//        println("Listing first 100 PMD violations")
+//
+//        file.eachLine { line, count ->
+//            if (count <= 100) {
+//               println(line)
+//            }
+//        }
+//
+//    } else {
+//        println("PMD file not found.")
+//    }
+//}
+
+//build.dependsOn pmdPrint
 
 animalsniffer {
     annotation = 'rx.internal.util.SuppressAnimalSniffer'
diff --git a/gradle/buildViaTravis.sh b/gradle/buildViaTravis.sh
index d98e5eb603..3da975d72f 100755
--- a/gradle/buildViaTravis.sh
+++ b/gradle/buildViaTravis.sh
@@ -1,9 +1,11 @@
 #!/bin/bash
 # This script will build the project.
 
+git fsck --full
+
 if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
   echo -e "Build Pull Request #$TRAVIS_PULL_REQUEST => Branch [$TRAVIS_BRANCH]"
-  ./gradlew -Prelease.useLastTag=true build
+  ./gradlew -Prelease.useLastTag=true build --stacktrace
 elif [ "$TRAVIS_PULL_REQUEST" == "false" ] && [ "$TRAVIS_TAG" == "" ]; then
   echo -e 'Build Branch with Snapshot => Branch ['$TRAVIS_BRANCH']'
   ./gradlew -Prelease.travisci=true -PbintrayUser="${bintrayUser}" -PbintrayKey="${bintrayKey}" -PsonatypeUsername="${sonatypeUsername}" -PsonatypePassword="${sonatypePassword}" build snapshot --stacktrace
@@ -12,5 +14,5 @@ elif [ "$TRAVIS_PULL_REQUEST" == "false" ] && [ "$TRAVIS_TAG" != "" ]; then
   ./gradlew -Prelease.travisci=true -Prelease.useLastTag=true -PbintrayUser="${bintrayUser}" -PbintrayKey="${bintrayKey}" -PsonatypeUsername="${sonatypeUsername}" -PsonatypePassword="${sonatypePassword}" final --stacktrace
 else
   echo -e 'WARN: Should not be here => Branch ['$TRAVIS_BRANCH']  Tag ['$TRAVIS_TAG']  Pull Request ['$TRAVIS_PULL_REQUEST']'
-  ./gradlew -Prelease.useLastTag=true build
+  ./gradlew -Prelease.useLastTag=true build --stacktrace
 fi

From cf154b1a07dce719cf36d2977e81c06b5cd3cd8c Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 9 Jul 2016 22:22:42 +0200
Subject: [PATCH 101/263] 1.x: add missing RxJavaHooks options, fix bugs
 (#4182)

---
 src/main/java/rx/plugins/RxJavaHooks.java     | 375 ++++++++++---
 src/main/java/rx/plugins/RxJavaPlugins.java   |   1 +
 src/test/java/rx/plugins/RxJavaHooksTest.java | 509 +++++++++++++++++-
 3 files changed, 815 insertions(+), 70 deletions(-)

diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index 1307c78417..b68e01c287 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -18,7 +18,7 @@
 import java.lang.Thread.UncaughtExceptionHandler;
 
 import rx.*;
-import rx.Completable.CompletableOnSubscribe;
+import rx.Completable.*;
 import rx.Observable.*;
 import rx.annotations.Experimental;
 import rx.functions.*;
@@ -68,6 +68,20 @@ public final class RxJavaHooks {
 
     static volatile Func1<Subscription, Subscription> onSingleReturn;
 
+    static volatile Func1<Throwable, Throwable> onObservableSubscribeError;
+
+    static volatile Func1<Throwable, Throwable> onSingleSubscribeError;
+
+    static volatile Func1<Throwable, Throwable> onCompletableSubscribeError;
+
+    @SuppressWarnings("rawtypes")
+    static volatile Func1<Operator, Operator> onObservableLift;
+
+    @SuppressWarnings("rawtypes")
+    static volatile Func1<Operator, Operator> onSingleLift;
+
+    static volatile Func1<CompletableOperator, CompletableOperator> onCompletableLift;
+
     /** Initialize with the default delegation to the original RxJavaPlugins. */
     static {
         init();
@@ -91,15 +105,6 @@ public void call(Throwable e) {
             }
         };
         
-        RxJavaPlugins.getInstance().getObservableExecutionHook();
-        
-        onObservableCreate = new Func1<OnSubscribe, OnSubscribe>() {
-            @Override
-            public OnSubscribe call(OnSubscribe f) {
-                return RxJavaPlugins.getInstance().getObservableExecutionHook().onCreate(f);
-            }
-        };
-        
         onObservableStart = new Func2<Observable, OnSubscribe, OnSubscribe>() {
             @Override
             public OnSubscribe call(Observable t1, OnSubscribe t2) {
@@ -114,15 +119,6 @@ public Subscription call(Subscription f) {
             }
         };
         
-        RxJavaPlugins.getInstance().getSingleExecutionHook();
-
-        onSingleCreate = new Func1<rx.Single.OnSubscribe, rx.Single.OnSubscribe>() {
-            @Override
-            public rx.Single.OnSubscribe call(rx.Single.OnSubscribe f) {
-                return RxJavaPlugins.getInstance().getSingleExecutionHook().onCreate(f);
-            }
-        };
-        
         onSingleStart = new Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe>() {
             @Override
             public Observable.OnSubscribe call(Single t1, Observable.OnSubscribe t2) {
@@ -137,15 +133,6 @@ public Subscription call(Subscription f) {
             }
         };
         
-        RxJavaPlugins.getInstance().getCompletableExecutionHook();
-
-        onCompletableCreate = new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
-            @Override
-            public CompletableOnSubscribe call(CompletableOnSubscribe f) {
-                return RxJavaPlugins.getInstance().getCompletableExecutionHook().onCreate(f);
-            }
-        };
-        
         onCompletableStart = new Func2<Completable, Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe>() {
             @Override
             public Completable.CompletableOnSubscribe call(Completable t1, Completable.CompletableOnSubscribe t2) {
@@ -159,6 +146,74 @@ public Action0 call(Action0 a) {
                 return RxJavaPlugins.getInstance().getSchedulersHook().onSchedule(a);
             }
         };
+        
+        onObservableSubscribeError = new Func1<Throwable, Throwable>() {
+            @Override
+            public Throwable call(Throwable t) {
+                return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeError(t);
+            }
+        };
+        
+        onObservableLift = new Func1<Operator, Operator>() {
+            @Override
+            public Operator call(Operator t) {
+                return RxJavaPlugins.getInstance().getObservableExecutionHook().onLift(t);
+            }
+        };
+
+        onSingleSubscribeError = new Func1<Throwable, Throwable>() {
+            @Override
+            public Throwable call(Throwable t) {
+                return RxJavaPlugins.getInstance().getSingleExecutionHook().onSubscribeError(t);
+            }
+        };
+        
+        onSingleLift = new Func1<Operator, Operator>() {
+            @Override
+            public Operator call(Operator t) {
+                return RxJavaPlugins.getInstance().getSingleExecutionHook().onLift(t);
+            }
+        };
+
+        onCompletableSubscribeError = new Func1<Throwable, Throwable>() {
+            @Override
+            public Throwable call(Throwable t) {
+                return RxJavaPlugins.getInstance().getCompletableExecutionHook().onSubscribeError(t);
+            }
+        };
+        
+        onCompletableLift = new Func1<CompletableOperator, CompletableOperator>() {
+            @Override
+            public CompletableOperator call(CompletableOperator t) {
+                return RxJavaPlugins.getInstance().getCompletableExecutionHook().onLift(t);
+            }
+        };
+
+        initCreate();
+    }
+    
+    @SuppressWarnings({ "rawtypes", "unchecked", "deprecation" })
+    static void initCreate() {
+        onObservableCreate = new Func1<OnSubscribe, OnSubscribe>() {
+            @Override
+            public OnSubscribe call(OnSubscribe f) {
+                return RxJavaPlugins.getInstance().getObservableExecutionHook().onCreate(f);
+            }
+        };
+
+        onSingleCreate = new Func1<rx.Single.OnSubscribe, rx.Single.OnSubscribe>() {
+            @Override
+            public rx.Single.OnSubscribe call(rx.Single.OnSubscribe f) {
+                return RxJavaPlugins.getInstance().getSingleExecutionHook().onCreate(f);
+            }
+        };
+
+        onCompletableCreate = new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
+            @Override
+            public CompletableOnSubscribe call(CompletableOnSubscribe f) {
+                return RxJavaPlugins.getInstance().getCompletableExecutionHook().onCreate(f);
+            }
+        };
     }
     
     /**
@@ -193,17 +248,25 @@ public static void clear() {
         onObservableCreate = null;
         onObservableStart = null;
         onObservableReturn = null;
+        onObservableSubscribeError = null;
+        onObservableLift = null;
         
         onSingleCreate = null;
         onSingleStart = null;
         onSingleReturn = null;
+        onSingleSubscribeError = null;
+        onSingleLift = null;
         
         onCompletableCreate = null;
         onCompletableStart = null;
+        onCompletableSubscribeError = null;
+        onCompletableLift = null;
         
         onComputationScheduler = null;
         onIOScheduler = null;
         onNewThreadScheduler = null;
+        
+        onScheduleAction = null;
     }
 
     /**
@@ -236,12 +299,19 @@ public static void onError(Throwable ex) {
                  * Since the plugin should never throw this is a safety net
                  * and will complain loudly to System.err so it gets fixed.
                  */
-                System.err.println("RxJavaErrorHandler threw an Exception. It shouldn't. => " + pluginException.getMessage()); // NOPMD 
-                pluginException.printStackTrace(); // NOPMD 
+                System.err.println("The onError handler threw an Exception. It shouldn't. => " + pluginException.getMessage()); // NOPMD 
+                pluginException.printStackTrace(); // NOPMD
+                
+                signalUncaught(pluginException);
             }
         }
+        signalUncaught(ex);
+    }
+    
+    static void signalUncaught(Throwable ex) {
         Thread current = Thread.currentThread();
-        current.getUncaughtExceptionHandler().uncaughtException(current, ex);
+        UncaughtExceptionHandler handler = current.getUncaughtExceptionHandler();
+        handler.uncaughtException(current, ex);
     }
     
     /**
@@ -375,7 +445,10 @@ public static Subscription onObservableReturn(Subscription subscription) {
      * @return the original error or alternative Throwable to be thrown
      */
     public static Throwable onObservableError(Throwable error) {
-        // TODO add hook
+        Func1<Throwable, Throwable> f = onObservableSubscribeError;
+        if (f != null) {
+            return f.call(error);
+        }
         return error;
     }
 
@@ -386,8 +459,12 @@ public static Throwable onObservableError(Throwable error) {
      * @param operator the original operator
      * @return the original or alternative operator that will be subscribed to
      */
+    @SuppressWarnings({ "rawtypes", "unchecked" })
     public static <T, R> Operator<R, T> onObservableLift(Operator<R, T> operator) {
-        // TODO add hook
+        Func1<Operator, Operator> f = onObservableLift;
+        if (f != null) {
+            return f.call(operator);
+        }
         return operator;
     }
 
@@ -426,7 +503,10 @@ public static Subscription onSingleReturn(Subscription subscription) {
      * @return the original error or alternative Throwable to be thrown
      */
     public static Throwable onSingleError(Throwable error) {
-        // TODO add hook
+        Func1<Throwable, Throwable> f = onSingleSubscribeError;
+        if (f != null) {
+            return f.call(error);
+        }
         return error;
     }
 
@@ -437,8 +517,12 @@ public static Throwable onSingleError(Throwable error) {
      * @param operator the original operator
      * @return the original or alternative operator that will be subscribed to
      */
+    @SuppressWarnings({ "rawtypes", "unchecked" })
     public static <T, R> Operator<R, T> onSingleLift(Operator<R, T> operator) {
-        // TODO add hook
+        Func1<Operator, Operator> f = onSingleLift;
+        if (f != null) {
+            return f.call(operator);
+        }
         return operator;
     }
 
@@ -463,7 +547,10 @@ public static <T> Completable.CompletableOnSubscribe onCompletableStart(Completa
      * @return the original error or alternative Throwable to be thrown
      */
     public static Throwable onCompletableError(Throwable error) {
-        // TODO add hook
+        Func1<Throwable, Throwable> f = onCompletableSubscribeError;
+        if (f != null) {
+            return f.call(error);
+        }
         return error;
     }
 
@@ -475,7 +562,10 @@ public static Throwable onCompletableError(Throwable error) {
      * @return the original or alternative operator that will be subscribed to
      */
     public static <T, R> Completable.CompletableOperator onCompletableLift(Completable.CompletableOperator operator) {
-        // TODO add hook
+        Func1<CompletableOperator, CompletableOperator> f = onCompletableLift;
+        if (f != null) {
+            return f.call(operator);
+        }
         return operator;
     }
 
@@ -721,7 +811,185 @@ public static void setOnSingleReturn(Func1<Subscription, Subscription> onSingleR
         }
         RxJavaHooks.onSingleReturn = onSingleReturn;
     }
+
+    /**
+     * Sets a hook function that is called when the Single.subscribe() call
+     * fails with an exception.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onSingleSubscribeError the function that is called with the crash exception and should return
+     * an exception.
+     */
+    public static void setOnSingleSubscribeError(Func1<Throwable, Throwable> onSingleSubscribeError) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onSingleSubscribeError = onSingleSubscribeError;
+    }
+
+    /**
+     * Returns the current Single onSubscribeError hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func1<Throwable, Throwable> getOnSingleSubscribeError() {
+        return onSingleSubscribeError;
+    }
+    
+    /**
+     * Sets a hook function that is called when the Completable.subscribe() call
+     * fails with an exception.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onCompletableSubscribeError the function that is called with the crash exception and should return
+     * an exception.
+     */
+    public static void setOnCompletableSubscribeError(Func1<Throwable, Throwable> onCompletableSubscribeError) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onCompletableSubscribeError = onCompletableSubscribeError;
+    }
+
+    /**
+     * Returns the current Completable onSubscribeError hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func1<Throwable, Throwable> getOnCompletableSubscribeError() {
+        return onCompletableSubscribeError;
+    }
+    
+    /**
+     * Sets a hook function that is called when the Observable.subscribe() call
+     * fails with an exception.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onObservableSubscribeError the function that is called with the crash exception and should return
+     * an exception.
+     */
+    public static void setOnObservableSubscribeError(Func1<Throwable, Throwable> onObservableSubscribeError) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onObservableSubscribeError = onObservableSubscribeError;
+    }
+
+    /**
+     * Returns the current Observable onSubscribeError hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func1<Throwable, Throwable> getOnObservableSubscribeError() {
+        return onObservableSubscribeError;
+    }
+    
+    /**
+     * Sets a hook function that is called with an operator when an Observable operator built with
+     * lift() gets subscribed to.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onObservableLift the function that is called with original Operator and should
+     * return an Operator instance.
+     */
+    @SuppressWarnings("rawtypes")
+    public static void setOnObservableLift(Func1<Operator, Operator> onObservableLift) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onObservableLift = onObservableLift;
+    }
+    
+    /**
+     * Returns the current Observable onLift hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    @SuppressWarnings("rawtypes")
+    public static Func1<Operator, Operator> getOnObservableLift() {
+        return onObservableLift;
+    }
+
+    /**
+     * Sets a hook function that is called with an operator when an Single operator built with
+     * lift() gets subscribed to.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onSingleLift the function that is called with original Operator and should
+     * return an Operator instance.
+     */
+    @SuppressWarnings("rawtypes")
+    public static void setOnSingleLift(Func1<Operator, Operator> onSingleLift) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onSingleLift = onSingleLift;
+    }
     
+    /**
+     * Returns the current Single onLift hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    @SuppressWarnings("rawtypes")
+    public static Func1<Operator, Operator> getOnSingleLift() {
+        return onSingleLift;
+    }
+
+    /**
+     * Sets a hook function that is called with an operator when an Completable operator built with
+     * lift() gets subscribed to.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * the hook returns the same object.
+     * @param onObservableLift the function that is called with original Operator and should
+     * return an Operator instance.
+     */
+    public static void setOnCompletableLift(Func1<CompletableOperator, CompletableOperator> onCompletableLift) {
+        if (lockdown) {
+            return;
+        }
+        RxJavaHooks.onCompletableLift = onCompletableLift;
+    }
+    
+    /**
+     * Returns the current Completable onLift hook function or null if it is
+     * set to the default pass-through.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current hook function
+     */
+    public static Func1<CompletableOperator, CompletableOperator> getOnCompletableLift() {
+        return onCompletableLift;
+    }
+
     /**
      * Returns the current computation scheduler hook function or null if it is
      * set to the default pass-through.
@@ -874,47 +1142,18 @@ public static Func1<Subscription, Subscription> getOnSingleReturn() {
      * Resets the assembly tracking hooks to their default delegates to
      * RxJavaPlugins.
      */
-    @SuppressWarnings({ "rawtypes", "unchecked", "deprecation" })
     public static void resetAssemblyTracking() {
         if (lockdown) {
             return;
         }
 
-        RxJavaPlugins plugin = RxJavaPlugins.getInstance();
-        
-        final RxJavaObservableExecutionHook observableExecutionHook = plugin.getObservableExecutionHook();
-        
-        onObservableCreate = new Func1<OnSubscribe, OnSubscribe>() {
-            @Override
-            public OnSubscribe call(OnSubscribe f) {
-                return observableExecutionHook.onCreate(f);
-            }
-        };
-        
-        final RxJavaSingleExecutionHook singleExecutionHook = plugin.getSingleExecutionHook();
-
-        onSingleCreate = new Func1<rx.Single.OnSubscribe, rx.Single.OnSubscribe>() {
-            @Override
-            public rx.Single.OnSubscribe call(rx.Single.OnSubscribe f) {
-                return singleExecutionHook.onCreate(f);
-            }
-        };
-        
-        final RxJavaCompletableExecutionHook completableExecutionHook = plugin.getCompletableExecutionHook();
-
-        onCompletableCreate = new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
-            @Override
-            public CompletableOnSubscribe call(CompletableOnSubscribe f) {
-                return completableExecutionHook.onCreate(f);
-            }
-        };
-
+        initCreate();
     }
 
     /**
      * Clears the assembly tracking hooks to their default pass-through behavior.
      */
-    public static void crearAssemblyTracking() {
+    public static void clearAssemblyTracking() {
         if (lockdown) {
             return;
         }
diff --git a/src/main/java/rx/plugins/RxJavaPlugins.java b/src/main/java/rx/plugins/RxJavaPlugins.java
index 184b4fdb1d..cc846fd6e1 100644
--- a/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -91,6 +91,7 @@ public void reset() {
         INSTANCE.errorHandler.set(null);
         INSTANCE.observableExecutionHook.set(null);
         INSTANCE.singleExecutionHook.set(null);
+        INSTANCE.completableExecutionHook.set(null);
         INSTANCE.schedulersHook.set(null);
     }
 
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index 56599cf874..f13c8514b7 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -15,7 +15,11 @@
  */
 package rx.plugins;
 
+import static org.junit.Assert.*;
+
+import java.lang.Thread.UncaughtExceptionHandler;
 import java.lang.reflect.Method;
+import java.util.*;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -23,7 +27,8 @@
 
 import rx.*;
 import rx.Completable.*;
-import rx.Observable.OnSubscribe;
+import rx.Observable;
+import rx.Observable.*;
 import rx.Scheduler.Worker;
 import rx.exceptions.*;
 import rx.functions.*;
@@ -33,7 +38,6 @@
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
-import static org.junit.Assert.*;
 
 
 public class RxJavaHooksTest {
@@ -69,6 +73,14 @@ public void assemblyTrackingObservable() {
             assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
             
             assertTrue(ex.getMessage(), ex.getMessage().contains("createObservable"));
+            
+            RxJavaHooks.clearAssemblyTracking();
+
+            ts = TestSubscriber.create();
+            
+            createObservable().subscribe(ts);
+
+            ts.assertError(TestException.class);
         } finally {
             RxJavaHooks.resetAssemblyTracking();
         }
@@ -100,6 +112,14 @@ public void assemblyTrackingSingle() {
             assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
 
             assertTrue(ex.getMessage(), ex.getMessage().contains("createSingle"));
+
+            RxJavaHooks.clearAssemblyTracking();
+
+            ts = TestSubscriber.create();
+            
+            createSingle().subscribe(ts);
+
+            ts.assertError(TestException.class);
         } finally {
             RxJavaHooks.resetAssemblyTracking();
         }
@@ -131,6 +151,15 @@ public void assemblyTrackingCompletable() {
             assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
 
             assertTrue(ex.getMessage(), ex.getMessage().contains("createCompletable"));
+
+            RxJavaHooks.clearAssemblyTracking();
+
+            ts = TestSubscriber.create();
+            
+            createCompletable().subscribe(ts);
+
+            ts.assertError(TestException.class);
+
         } finally {
             RxJavaHooks.resetAssemblyTracking();
         }
@@ -142,6 +171,7 @@ public void lockdown() throws Exception {
         RxJavaHooks.reset();
         RxJavaHooks.lockdown();
         try {
+            assertTrue(RxJavaHooks.isLockdown());
             Action1 a1 = Actions.empty();
             Func1 f1 = UtilityFunctions.identity();
             Func2 f2 = new Func2() {
@@ -170,12 +200,33 @@ public Object call(Object t1, Object t2) {
                     Object after = getter.invoke(null);
                     
                     assertSame(m.toString(), before, after);
+                    
+                    if (before != null) {
+                        RxJavaHooks.clear();
+                        RxJavaHooks.reset();
+                        assertSame(m.toString(), before, getter.invoke(null));
+                    }
                 }
             }
             
+            
+            Object o1 = RxJavaHooks.getOnObservableCreate();
+            Object o2 = RxJavaHooks.getOnSingleCreate();
+            Object o3 = RxJavaHooks.getOnCompletableCreate();
+            
+            RxJavaHooks.enableAssemblyTracking();
+            RxJavaHooks.clearAssemblyTracking();
+            RxJavaHooks.resetAssemblyTracking();
+
+            
+            assertSame(o1, RxJavaHooks.getOnObservableCreate());
+            assertSame(o2, RxJavaHooks.getOnSingleCreate());
+            assertSame(o3, RxJavaHooks.getOnCompletableCreate());
+            
         } finally {
             RxJavaHooks.lockdown = false;
             RxJavaHooks.reset();
+            assertFalse(RxJavaHooks.isLockdown());
         }
     }
     
@@ -552,4 +603,458 @@ public void onScheduleNewThread() throws InterruptedException {
         onSchedule(Schedulers.newThread().createWorker());
     }
 
+    @Test
+    public void onError() {
+        try {
+            final List<Throwable> list = new ArrayList<Throwable>();
+            
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+                @Override
+                public void call(Throwable t) {
+                    list.add(t);
+                }
+            });
+            
+            RxJavaHooks.onError(new TestException("Forced failure"));
+            
+            assertEquals(1, list.size());
+            assertTestException(list, 0, "Forced failure");
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+    
+    @Test
+    public void clear() throws Exception {
+        RxJavaHooks.reset();
+        try {
+            RxJavaHooks.clear();
+            for (Method m : RxJavaHooks.class.getMethods()) {
+                if (m.getName().startsWith("getOn")) {
+                    assertNull(m.toString(), m.invoke(null));
+                }
+            }
+
+        } finally {
+            RxJavaHooks.reset();
+        }
+
+        for (Method m : RxJavaHooks.class.getMethods()) {
+            if (m.getName().startsWith("getOn") && !m.getName().endsWith("Scheduler")) {
+                assertNotNull(m.toString(), m.invoke(null));
+            }
+        }
+
+    }
+
+    @Test
+    public void onErrorNoHandler() {
+        try {
+            final List<Throwable> list = new ArrayList<Throwable>();
+            
+            RxJavaHooks.setOnError(null);
+            
+            Thread.currentThread().setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+                
+                @Override
+                public void uncaughtException(Thread t, Throwable e) {
+                    list.add(e);
+                    
+                }
+            });
+            
+            RxJavaHooks.onError(new TestException("Forced failure"));
+
+            Thread.currentThread().setUncaughtExceptionHandler(null);
+
+            // this will be printed on the console and should not crash
+            RxJavaHooks.onError(new TestException("Forced failure 3"));
+
+            assertEquals(1, list.size());
+            assertTestException(list, 0, "Forced failure");
+        } finally {
+            RxJavaHooks.reset();
+            Thread.currentThread().setUncaughtExceptionHandler(null);
+        }
+    }
+
+    @Test
+    public void onErrorCrashes() {
+        try {
+            final List<Throwable> list = new ArrayList<Throwable>();
+            
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+                @Override
+                public void call(Throwable t) {
+                    throw new TestException("Forced failure 2");
+                }
+            });
+
+            Thread.currentThread().setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+                
+                @Override
+                public void uncaughtException(Thread t, Throwable e) {
+                    list.add(e);
+                    
+                }
+            });
+
+            RxJavaHooks.onError(new TestException("Forced failure"));
+            
+            assertEquals(2, list.size());
+            assertTestException(list, 0, "Forced failure 2");
+            assertTestException(list, 1, "Forced failure");
+
+            Thread.currentThread().setUncaughtExceptionHandler(null);
+            
+        } finally {
+            RxJavaHooks.reset();
+            Thread.currentThread().setUncaughtExceptionHandler(null);
+        }
+    }
+
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    @Test
+    public void clearIsPassthrough() {
+        try {
+            RxJavaHooks.clear();
+            
+            assertNull(RxJavaHooks.onCreate((Observable.OnSubscribe)null));
+
+            Observable.OnSubscribe oos = new Observable.OnSubscribe() {
+                @Override
+                public void call(Object t) {
+                    
+                }
+            };
+
+            assertSame(oos, RxJavaHooks.onCreate(oos));
+            
+            assertNull(RxJavaHooks.onCreate((Single.OnSubscribe)null));
+
+            Single.OnSubscribe sos = new Single.OnSubscribe() {
+                @Override
+                public void call(Object t) {
+                    
+                }
+            };
+
+            assertSame(sos, RxJavaHooks.onCreate(sos));
+            
+            assertNull(RxJavaHooks.onCreate((Single.OnSubscribe)null));
+
+            Completable.CompletableOnSubscribe cos = new Completable.CompletableOnSubscribe() {
+                @Override
+                public void call(CompletableSubscriber t) {
+                    
+                }
+            };
+
+            assertSame(cos, RxJavaHooks.onCreate(cos));
+            
+            assertNull(RxJavaHooks.onScheduledAction(null));
+            
+            Action0 action = Actions.empty();
+            
+            assertSame(action, RxJavaHooks.onScheduledAction(action));
+            
+            
+            assertNull(RxJavaHooks.onObservableStart(Observable.never(), null));
+            
+            assertSame(oos, RxJavaHooks.onObservableStart(Observable.never(), oos));
+
+            assertNull(RxJavaHooks.onSingleStart(Single.just(1), null));
+            
+            assertSame(oos, RxJavaHooks.onSingleStart(Single.just(1), oos));
+
+            assertNull(RxJavaHooks.onCompletableStart(Completable.never(), null));
+            
+            assertSame(cos, RxJavaHooks.onCompletableStart(Completable.never(), cos));
+            
+            Subscription subscription = Subscriptions.empty();
+            
+            assertNull(RxJavaHooks.onObservableReturn(null));
+            
+            assertSame(subscription, RxJavaHooks.onObservableReturn(subscription));
+
+            assertNull(RxJavaHooks.onSingleReturn(null));
+            
+            assertSame(subscription, RxJavaHooks.onSingleReturn(subscription));
+
+            TestException ex = new TestException();
+            
+            assertNull(RxJavaHooks.onObservableError(null));
+            
+            assertSame(ex, RxJavaHooks.onObservableError(ex));
+
+            assertNull(RxJavaHooks.onSingleError(null));
+            
+            assertSame(ex, RxJavaHooks.onSingleError(ex));
+
+            assertNull(RxJavaHooks.onCompletableError(null));
+            
+            assertSame(ex, RxJavaHooks.onCompletableError(ex));
+
+            Observable.Operator oop = new Observable.Operator() {
+                @Override
+                public Object call(Object t) {
+                    return t;
+                }
+            };
+            
+            assertNull(RxJavaHooks.onObservableLift(null));
+            
+            assertSame(oop, RxJavaHooks.onObservableLift(oop));
+            
+            assertNull(RxJavaHooks.onSingleLift(null));
+            
+            assertSame(oop, RxJavaHooks.onSingleLift(oop));
+            
+            Completable.CompletableOperator cop = new Completable.CompletableOperator() {
+                @Override
+                public CompletableSubscriber call(CompletableSubscriber t) {
+                    return t;
+                }
+            };
+            
+            assertNull(RxJavaHooks.onCompletableLift(null));
+            
+            assertSame(cop, RxJavaHooks.onCompletableLift(cop));
+            
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+    
+    static void assertTestException(List<Throwable> list, int index, String message) {
+        assertTrue(list.get(index).toString(), list.get(index) instanceof TestException);
+        assertEquals(message, list.get(index).getMessage());
+    }
+    
+    @Test
+    public void onXError() {
+        try {
+            final List<Throwable> list = new ArrayList<Throwable>();
+            
+            final TestException ex = new TestException();
+            
+            Func1<Throwable, Throwable> errorHandler = new Func1<Throwable, Throwable>() {
+                @Override
+                public Throwable call(Throwable t) {
+                    list.add(t);
+                    return ex;
+                }
+            };
+            
+            RxJavaHooks.setOnObservableSubscribeError(errorHandler);
+
+            RxJavaHooks.setOnSingleSubscribeError(errorHandler);
+
+            RxJavaHooks.setOnCompletableSubscribeError(errorHandler);
+
+            assertSame(ex, RxJavaHooks.onObservableError(new TestException("Forced failure 1")));
+
+            assertSame(ex, RxJavaHooks.onSingleError(new TestException("Forced failure 2")));
+            
+            assertSame(ex, RxJavaHooks.onCompletableError(new TestException("Forced failure 3")));
+            
+            assertTestException(list, 0, "Forced failure 1");
+            
+            assertTestException(list, 1, "Forced failure 2");
+
+            assertTestException(list, 2, "Forced failure 3");
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void onPluginsXError() {
+        try {
+            RxJavaPlugins.getInstance().reset();
+            RxJavaHooks.reset();
+            
+            final List<Throwable> list = new ArrayList<Throwable>();
+            
+            final TestException ex = new TestException();
+            
+            final Func1<Throwable, Throwable> errorHandler = new Func1<Throwable, Throwable>() {
+                @Override
+                public Throwable call(Throwable t) {
+                    list.add(t);
+                    return ex;
+                }
+            };
+
+            RxJavaPlugins.getInstance().registerObservableExecutionHook(new RxJavaObservableExecutionHook() {
+                @Override
+                public <T> Throwable onSubscribeError(Throwable e) {
+                    return errorHandler.call(e);
+                }
+            });
+
+            RxJavaPlugins.getInstance().registerSingleExecutionHook(new RxJavaSingleExecutionHook() {
+                @Override
+                public <T> Throwable onSubscribeError(Throwable e) {
+                    return errorHandler.call(e);
+                }
+            });
+
+            RxJavaPlugins.getInstance().registerCompletableExecutionHook(new RxJavaCompletableExecutionHook() {
+                @Override
+                public Throwable onSubscribeError(Throwable e) {
+                    return errorHandler.call(e);
+                }
+            });
+
+            assertSame(ex, RxJavaHooks.onObservableError(new TestException("Forced failure 1")));
+
+            assertSame(ex, RxJavaHooks.onSingleError(new TestException("Forced failure 2")));
+            
+            assertSame(ex, RxJavaHooks.onCompletableError(new TestException("Forced failure 3")));
+            
+            assertTestException(list, 0, "Forced failure 1");
+            
+            assertTestException(list, 1, "Forced failure 2");
+
+            assertTestException(list, 2, "Forced failure 3");
+        } finally {
+            RxJavaPlugins.getInstance().reset();
+            RxJavaHooks.reset();
+        }
+    }
+
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    @Test
+    public void onXLift() {
+        try {
+            Completable.CompletableOperator cop = new Completable.CompletableOperator() {
+                @Override
+                public CompletableSubscriber call(CompletableSubscriber t) {
+                    return t;
+                }
+            };
+            
+            Observable.Operator oop = new Observable.Operator() {
+                @Override
+                public Object call(Object t) {
+                    return t;
+                }
+            };
+
+            final int[] counter = { 0 };
+
+            RxJavaHooks.setOnObservableLift(new Func1<Operator, Operator>() {
+                @Override
+                public Operator call(Operator t) {
+                    counter[0]++;
+                    return t;
+                }
+            });
+
+            RxJavaHooks.setOnSingleLift(new Func1<Operator, Operator>() {
+                @Override
+                public Operator call(Operator t) {
+                    counter[0]++;
+                    return t;
+                }
+            });
+
+            RxJavaHooks.setOnCompletableLift(new Func1<CompletableOperator, CompletableOperator>() {
+                @Override
+                public CompletableOperator call(CompletableOperator t) {
+                    counter[0]++;
+                    return t;
+                }
+            });
+            
+            assertSame(oop, RxJavaHooks.onObservableLift(oop));
+
+            assertSame(oop, RxJavaHooks.onSingleLift(oop));
+
+            assertSame(cop, RxJavaHooks.onCompletableLift(cop));
+            
+            assertEquals(3, counter[0]);
+
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+
+    @SuppressWarnings({ "rawtypes", "unchecked", "deprecation" })
+    @Test
+    public void onPluginsXLift() {
+        try {
+            
+            RxJavaPlugins.getInstance().reset();
+            RxJavaHooks.reset();
+
+            Completable.CompletableOperator cop = new Completable.CompletableOperator() {
+                @Override
+                public CompletableSubscriber call(CompletableSubscriber t) {
+                    return t;
+                }
+            };
+            
+            Observable.Operator oop = new Observable.Operator() {
+                @Override
+                public Object call(Object t) {
+                    return t;
+                }
+            };
+
+            final int[] counter = { 0 };
+
+            final Func1<Operator, Operator> onObservableLift = new Func1<Operator, Operator>() {
+                @Override
+                public Operator call(Operator t) {
+                    counter[0]++;
+                    return t;
+                }
+            };
+
+            final Func1<CompletableOperator, CompletableOperator> onCompletableLift = new Func1<CompletableOperator, CompletableOperator>() {
+                @Override
+                public CompletableOperator call(CompletableOperator t) {
+                    counter[0]++;
+                    return t;
+                }
+            };
+            
+            RxJavaPlugins.getInstance().registerObservableExecutionHook(new RxJavaObservableExecutionHook() {
+                @Override
+                public <T, R> Operator<? extends R, ? super T> onLift(Operator<? extends R, ? super T> lift) {
+                    return onObservableLift.call(lift);
+                }
+            });
+            
+            RxJavaPlugins.getInstance().registerSingleExecutionHook(new RxJavaSingleExecutionHook() {
+                @Override
+                public <T, R> Operator<? extends R, ? super T> onLift(Operator<? extends R, ? super T> lift) {
+                    return onObservableLift.call(lift);
+                }
+            });
+            
+            RxJavaPlugins.getInstance().registerCompletableExecutionHook(new RxJavaCompletableExecutionHook() {
+                @Override
+                public CompletableOperator onLift(CompletableOperator lift) {
+                    return onCompletableLift.call(lift);
+                }
+            });
+            
+            assertSame(oop, RxJavaHooks.onObservableLift(oop));
+
+            assertSame(oop, RxJavaHooks.onSingleLift(oop));
+
+            assertSame(cop, RxJavaHooks.onCompletableLift(cop));
+            
+            assertEquals(3, counter[0]);
+
+        } finally {
+            RxJavaPlugins.getInstance().reset();
+            RxJavaHooks.reset();
+        }
+    }
+
 }

From b9af588a2cf75d57e85c4f8677943eedbb03f03c Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 9 Jul 2016 22:44:00 +0200
Subject: [PATCH 102/263] 1.x: increase Coverage of some classes (#4181)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* 1.x: increase Coverage of some classes

* Suppress animalsniffer in unsafe using ó tests
---
 .../rx/internal/util/UtilityFunctions.java    |   4 +-
 .../rx/schedulers/ImmediateScheduler.java     |   2 +-
 .../rx/schedulers/NewThreadScheduler.java     |   2 +-
 src/main/java/rx/schedulers/Timestamped.java  |   9 +-
 .../rx/schedulers/TrampolineScheduler.java    |   2 +-
 .../DeferredScalarSubscriberTest.java         |   6 +-
 .../ProducerObserverArbiterTest.java          |  76 +++++++++++++
 .../rx/internal/producers/ProducersTest.java  |  94 +++++++++++++++
 .../rx/internal/util/ExceptionUtilsTest.java  |  13 +++
 .../internal/util/UtilityFunctionsTest.java   |  16 +++
 .../schedulers/DeprecatedSchedulersTest.java  |  73 ++++++++++++
 src/test/java/rx/schedulers/TimeXTest.java    | 107 ++++++++++++++++++
 12 files changed, 390 insertions(+), 14 deletions(-)
 create mode 100644 src/test/java/rx/schedulers/DeprecatedSchedulersTest.java
 create mode 100644 src/test/java/rx/schedulers/TimeXTest.java

diff --git a/src/main/java/rx/internal/util/UtilityFunctions.java b/src/main/java/rx/internal/util/UtilityFunctions.java
index 3bf6a9060c..68f6da339c 100644
--- a/src/main/java/rx/internal/util/UtilityFunctions.java
+++ b/src/main/java/rx/internal/util/UtilityFunctions.java
@@ -59,7 +59,7 @@ public T call(T o) {
         };
     }
 
-    private enum AlwaysTrue implements Func1<Object, Boolean> {
+    enum AlwaysTrue implements Func1<Object, Boolean> {
         INSTANCE;
 
         @Override
@@ -68,7 +68,7 @@ public Boolean call(Object o) {
         }
     }
 
-    private enum AlwaysFalse implements Func1<Object, Boolean> {
+    enum AlwaysFalse implements Func1<Object, Boolean> {
         INSTANCE;
 
         @Override
diff --git a/src/main/java/rx/schedulers/ImmediateScheduler.java b/src/main/java/rx/schedulers/ImmediateScheduler.java
index a187a5aa51..2a4cc4d823 100644
--- a/src/main/java/rx/schedulers/ImmediateScheduler.java
+++ b/src/main/java/rx/schedulers/ImmediateScheduler.java
@@ -24,7 +24,7 @@
 // Class was part of public API.
 public final class ImmediateScheduler extends Scheduler { // NOPMD 
     private ImmediateScheduler() {
-        throw new AssertionError();
+        throw new IllegalStateException("No instances!");
     }
 
     @Override
diff --git a/src/main/java/rx/schedulers/NewThreadScheduler.java b/src/main/java/rx/schedulers/NewThreadScheduler.java
index a8d3221d3d..c17165ddde 100644
--- a/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -24,7 +24,7 @@
 // Class was part of public API.
 public final class NewThreadScheduler extends Scheduler { // NOPMD 
     private NewThreadScheduler() {
-        throw new AssertionError();
+        throw new IllegalStateException("No instances!");
     }
 
     @Override
diff --git a/src/main/java/rx/schedulers/Timestamped.java b/src/main/java/rx/schedulers/Timestamped.java
index f741ccbc4a..cce5c210ff 100644
--- a/src/main/java/rx/schedulers/Timestamped.java
+++ b/src/main/java/rx/schedulers/Timestamped.java
@@ -61,14 +61,7 @@ public boolean equals(Object obj) {
         if (timestampMillis != other.timestampMillis) {
             return false;
         }
-        if (value == null) {
-            if (other.value != null) {
-                return false;
-            }
-        } else if (!value.equals(other.value)) {
-            return false;
-        }
-        return true;
+        return (value == other.value) || (value != null && value.equals(other.value));
     }
 
     @Override
diff --git a/src/main/java/rx/schedulers/TrampolineScheduler.java b/src/main/java/rx/schedulers/TrampolineScheduler.java
index d14e0d2cb8..48fb332e54 100644
--- a/src/main/java/rx/schedulers/TrampolineScheduler.java
+++ b/src/main/java/rx/schedulers/TrampolineScheduler.java
@@ -24,7 +24,7 @@
 // Class was part of public API.
 public final class TrampolineScheduler extends Scheduler { // NOPMD 
     private TrampolineScheduler() {
-        throw new AssertionError();
+        throw new IllegalStateException("No instances!");
     }
 
     @Override
diff --git a/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java b/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
index 0b91189222..59c52ac17e 100644
--- a/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
+++ b/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
@@ -343,8 +343,12 @@ public void call() {
     public void emissionRequestRace2() {
         Worker w = Schedulers.io().createWorker();
         Worker w2 = Schedulers.io().createWorker();
+        int m = 10000;
+        if (Runtime.getRuntime().availableProcessors() < 3) {
+            m = 1000;
+        }
         try {
-            for (int i = 0; i < 10000; i++) {
+            for (int i = 0; i < m; i++) {
     
                 final TestSubscriber<Integer> ts = TestSubscriber.create(0L);
                 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
diff --git a/src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java b/src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java
index 8e0c826ba6..02c2f18c34 100644
--- a/src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java
+++ b/src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java
@@ -16,6 +16,7 @@
 package rx.internal.producers;
 
 import org.junit.*;
+import static org.junit.Assert.*;
 
 import rx.*;
 import rx.exceptions.TestException;
@@ -38,6 +39,7 @@ public void negativeRequestThrows() {
     public void nullProducerAccepted() {
         ProducerObserverArbiter<Integer> pa = new ProducerObserverArbiter<Integer>(Subscribers.empty());
         pa.setProducer(null);
+        pa.request(5);
     }
 
     public void failedRequestUnlocksEmitting() {
@@ -160,4 +162,78 @@ public void onNext(Integer t) {
         }
     }
 
+    @Test
+    public void onNextRequests() {
+        @SuppressWarnings("rawtypes")
+        final ProducerObserverArbiter[] o = { null };
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                o[0].request(1);
+            }
+        };
+        ProducerObserverArbiter<Integer> poa = new ProducerObserverArbiter<Integer>(ts);
+        poa.request(1);
+        o[0] = poa;
+        try {
+            poa.onNext(1);
+        } catch (TestException ex) {
+            // expected
+        }
+        assertEquals(1, poa.requested);
+    }
+    
+    @Test
+    public void requestIsCapped() {
+        ProducerObserverArbiter<Integer> poa = new ProducerObserverArbiter<Integer>(new TestSubscriber<Integer>());
+    
+        poa.request(Long.MAX_VALUE - 1);
+        poa.request(2);
+        
+        assertEquals(Long.MAX_VALUE, Long.MAX_VALUE);
+    }
+
+    @Test
+    public void onNextChangesProducerNull() {
+        @SuppressWarnings("rawtypes")
+        final ProducerObserverArbiter[] o = { null };
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                o[0].setProducer(null);
+            }
+        };
+        ProducerObserverArbiter<Integer> poa = new ProducerObserverArbiter<Integer>(ts);
+        poa.request(1);
+        o[0] = poa;
+        try {
+            poa.onNext(1);
+        } catch (TestException ex) {
+            // expected
+        }
+        assertNull(poa.currentProducer);
+    }
+
+    @Test
+    public void onNextChangesProducerNotNull() {
+        @SuppressWarnings("rawtypes")
+        final ProducerObserverArbiter[] o = { null };
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
+            @SuppressWarnings("unchecked")
+            @Override
+            public void onNext(Integer t) {
+                o[0].setProducer(new SingleProducer<Integer>(o[0].child, 2));
+            }
+        };
+        ProducerObserverArbiter<Integer> poa = new ProducerObserverArbiter<Integer>(ts);
+        poa.request(1);
+        o[0] = poa;
+        try {
+            poa.onNext(1);
+        } catch (TestException ex) {
+            // expected
+        }
+        assertNotNull(poa.currentProducer);
+    }
+
 }
diff --git a/src/test/java/rx/internal/producers/ProducersTest.java b/src/test/java/rx/internal/producers/ProducersTest.java
index cda5a17d32..e482bec8a8 100644
--- a/src/test/java/rx/internal/producers/ProducersTest.java
+++ b/src/test/java/rx/internal/producers/ProducersTest.java
@@ -15,6 +15,7 @@
  */
 package rx.internal.producers;
 
+import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
 import java.util.*;
@@ -25,8 +26,10 @@
 import rx.*;
 import rx.Observable;
 import rx.Observable.*;
+import rx.exceptions.MissingBackpressureException;
 import rx.Observer;
 import rx.functions.*;
+import rx.internal.util.unsafe.SpscArrayQueue;
 import rx.observers.TestSubscriber;
 import rx.schedulers.*;
 import rx.subscriptions.SerialSubscription;
@@ -426,4 +429,95 @@ public void onNext(Integer t) {
             }
         });
     }
+    
+    @Test
+    public void queuedProducerRequestNegative() {
+        QueuedProducer<Integer> qp = new QueuedProducer<Integer>(new TestSubscriber<Integer>());
+        try {
+            qp.request(-99);
+        } catch (IllegalArgumentException ex) {
+            assertEquals("n >= 0 required", ex.getMessage());
+        }
+    }
+
+    @Test
+    public void queuedProducerOfferNull() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        QueuedProducer<Integer> qp = new QueuedProducer<Integer>(ts);
+        qp.offer(null);
+        
+        qp.request(1);
+        
+        ts.assertValue(null);
+    }
+
+    @Test
+    public void queuedProducerFull() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        QueuedProducer<Integer> qp = new QueuedProducer<Integer>(ts, new SpscArrayQueue<Object>(1));
+        assertTrue(qp.offer(1));
+        assertFalse(qp.offer(2));
+        
+        qp.request(1);
+        
+        ts.assertValue(1);
+    }
+
+    @Test
+    public void queuedProducerOnNextFull() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        QueuedProducer<Integer> qp = new QueuedProducer<Integer>(ts, new SpscArrayQueue<Object>(1));
+
+        qp.onNext(1);
+        qp.onNext(2);
+        
+        qp.request(1);
+        
+        ts.assertError(MissingBackpressureException.class);
+    }
+
+    @Test
+    public void queuedProducerOnNextFullWithNull() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        QueuedProducer<Integer> qp = new QueuedProducer<Integer>(ts, new SpscArrayQueue<Object>(1));
+
+        qp.onNext(1);
+        qp.onNext(null);
+        
+        qp.request(1);
+        
+        ts.assertError(MissingBackpressureException.class);
+    }
+
+    @Test
+    public void queuedProducerRequestCompletes() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        QueuedProducer<Integer> qp = new QueuedProducer<Integer>(ts, new SpscArrayQueue<Object>(1));
+
+        qp.onNext(1);
+        qp.onCompleted();
+        
+        qp.request(2);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void queuedProducerUnsubscribed() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        ts.unsubscribe();
+        QueuedProducer<Integer> qp = new QueuedProducer<Integer>(ts, new SpscArrayQueue<Object>(1));
+
+        qp.onNext(1);
+        qp.onCompleted();
+        
+        qp.request(2);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
 }
diff --git a/src/test/java/rx/internal/util/ExceptionUtilsTest.java b/src/test/java/rx/internal/util/ExceptionUtilsTest.java
index 73400f9069..16caa06deb 100644
--- a/src/test/java/rx/internal/util/ExceptionUtilsTest.java
+++ b/src/test/java/rx/internal/util/ExceptionUtilsTest.java
@@ -15,6 +15,8 @@
  */
 package rx.internal.util;
 
+import static org.junit.Assert.*;
+
 import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.*;
@@ -51,4 +53,15 @@ public void isTerminated() {
         Assert.assertTrue(ExceptionsUtils.isTerminated(error));
         Assert.assertTrue(ExceptionsUtils.isTerminated(error.get()));
     }
+    
+    @Test
+    public void utilityEnum() {
+        assertEquals(0, ExceptionsUtils.values().length);
+        try {
+            ExceptionsUtils.valueOf("INSTANCE");
+            fail("Failed to throw IllegalArgumentException");
+        } catch (IllegalArgumentException ex) {
+            // expected
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/util/UtilityFunctionsTest.java b/src/test/java/rx/internal/util/UtilityFunctionsTest.java
index f30fdf1e98..b8342652e2 100644
--- a/src/test/java/rx/internal/util/UtilityFunctionsTest.java
+++ b/src/test/java/rx/internal/util/UtilityFunctionsTest.java
@@ -16,6 +16,7 @@
 package rx.internal.util;
 
 import org.junit.Test;
+import static org.junit.Assert.*;
 
 import rx.TestUtil;
 
@@ -24,4 +25,19 @@ public class UtilityFunctionsTest {
     public void constructorShouldBePrivate() {
         TestUtil.checkUtilityClass(UtilityFunctions.class);
     }
+    
+    @Test
+    public void alwaysFalse() {
+        assertEquals(1, UtilityFunctions.AlwaysFalse.values().length);
+        assertNotNull(UtilityFunctions.AlwaysFalse.valueOf("INSTANCE"));
+        assertFalse(UtilityFunctions.alwaysFalse().call(1));
+    }
+
+    @Test
+    public void alwaysTrue() {
+        assertEquals(1, UtilityFunctions.AlwaysTrue.values().length);
+        assertNotNull(UtilityFunctions.AlwaysTrue.valueOf("INSTANCE"));
+        assertTrue(UtilityFunctions.alwaysTrue().call(1));
+    }
+
 }
diff --git a/src/test/java/rx/schedulers/DeprecatedSchedulersTest.java b/src/test/java/rx/schedulers/DeprecatedSchedulersTest.java
new file mode 100644
index 0000000000..b6ac98c67d
--- /dev/null
+++ b/src/test/java/rx/schedulers/DeprecatedSchedulersTest.java
@@ -0,0 +1,73 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.schedulers;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+import rx.*;
+import rx.internal.util.SuppressAnimalSniffer;
+import rx.internal.util.unsafe.UnsafeAccess;
+
+@SuppressWarnings("deprecation")
+@SuppressAnimalSniffer
+public class DeprecatedSchedulersTest {
+
+    @Test
+    public void immediate() {
+        TestUtil.checkUtilityClass(ImmediateScheduler.class);
+    }
+
+    @Test
+    public void newThread() {
+        TestUtil.checkUtilityClass(NewThreadScheduler.class);
+    }
+
+    @Test
+    public void trampoline() {
+        TestUtil.checkUtilityClass(TrampolineScheduler.class);
+    }
+
+    void checkWorker(Class<?> schedulerClass) {
+        if (UnsafeAccess.isUnsafeAvailable()) {
+            try {
+                Scheduler s =  (Scheduler)UnsafeAccess.UNSAFE.allocateInstance(schedulerClass);
+                
+                assertNull(s.createWorker());
+            } catch (InstantiationException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+    }
+    
+    @Test
+    public void immediateWorker() {
+        checkWorker(ImmediateScheduler.class);
+    }
+
+    @Test
+    public void newThreadWorker() {
+        checkWorker(NewThreadScheduler.class);
+    }
+    
+    @Test
+    public void trampolineWorker() {
+        checkWorker(TrampolineScheduler.class);
+    }
+
+
+}
diff --git a/src/test/java/rx/schedulers/TimeXTest.java b/src/test/java/rx/schedulers/TimeXTest.java
new file mode 100644
index 0000000000..d0fde5287f
--- /dev/null
+++ b/src/test/java/rx/schedulers/TimeXTest.java
@@ -0,0 +1,107 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.schedulers;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class TimeXTest {
+
+    @Test
+    public void timestamped() {
+        Timestamped<Integer> ts1 = new Timestamped<Integer>(1L, 1);
+        Timestamped<Integer> ts2 = new Timestamped<Integer>(1L, 1);
+        Timestamped<Integer> ts3 = new Timestamped<Integer>(3L, 1);
+        Timestamped<Integer> ts4 = new Timestamped<Integer>(3L, 2);
+        Timestamped<Integer> ts5 = new Timestamped<Integer>(4L, null);
+        Timestamped<Integer> ts6 = new Timestamped<Integer>(4L, null);
+        Timestamped<Integer> ts7 = new Timestamped<Integer>(1L, new Integer(1)); // have unique reference
+        Timestamped<Integer> ts8 = new Timestamped<Integer>(1L, 3);
+        Timestamped<Integer> ts9 = new Timestamped<Integer>(1L, null);
+        
+        assertEquals(1L, ts1.getTimestampMillis());
+        assertEquals(1, ts1.getValue().intValue());
+        
+        assertNotEquals(ts1, null);
+        assertNotEquals(ts1, "string");
+        
+        assertEquals(ts1, ts1);
+        assertEquals(ts1, ts2);
+        assertEquals(ts1, ts7);
+        assertEquals(ts7, ts1);
+        
+        assertNotEquals(ts1, ts3);
+        assertNotEquals(ts1, ts4);
+        assertNotEquals(ts1, ts8);
+        assertNotEquals(ts8, ts1);
+        assertNotEquals(ts1, ts9);
+        assertNotEquals(ts9, ts1);
+        
+        assertNotEquals(ts1, ts5);
+        assertNotEquals(ts5, ts1);
+        
+        assertEquals(ts5, ts6);
+        
+        assertEquals("Timestamped(timestampMillis = 1, value = 1)", ts1.toString());
+        
+        assertEquals(ts1.hashCode(), ts2.hashCode());
+
+        assertEquals(ts5.hashCode(), ts6.hashCode());
+    }
+
+    @Test
+    public void timeInterval() {
+        TimeInterval<Integer> ts1 = new TimeInterval<Integer>(1L, 1);
+        TimeInterval<Integer> ts2 = new TimeInterval<Integer>(1L, 1);
+        TimeInterval<Integer> ts3 = new TimeInterval<Integer>(3L, 1);
+        TimeInterval<Integer> ts4 = new TimeInterval<Integer>(3L, 2);
+        TimeInterval<Integer> ts5 = new TimeInterval<Integer>(4L, null);
+        TimeInterval<Integer> ts6 = new TimeInterval<Integer>(4L, null);
+        TimeInterval<Integer> ts7 = new TimeInterval<Integer>(1L, new Integer(1)); // have unique reference
+        TimeInterval<Integer> ts8 = new TimeInterval<Integer>(1L, 3);
+        TimeInterval<Integer> ts9 = new TimeInterval<Integer>(1L, null);
+        
+        assertEquals(1L, ts1.getIntervalInMilliseconds());
+        assertEquals(1, ts1.getValue().intValue());
+        
+        assertNotEquals(ts1, null);
+        assertNotEquals(ts1, "string");
+        
+        assertEquals(ts1, ts1);
+        assertEquals(ts1, ts2);
+        assertEquals(ts1, ts7);
+        assertEquals(ts7, ts1);
+        
+        assertNotEquals(ts1, ts3);
+        assertNotEquals(ts1, ts4);
+        assertNotEquals(ts1, ts8);
+        assertNotEquals(ts8, ts1);
+        assertNotEquals(ts1, ts9);
+        assertNotEquals(ts9, ts1);
+        
+        assertNotEquals(ts1, ts5);
+        assertNotEquals(ts5, ts1);
+        
+        assertEquals(ts5, ts6);
+        
+        assertEquals("TimeInterval [intervalInMilliseconds=1, value=1]", ts1.toString());
+        
+        assertEquals(ts1.hashCode(), ts2.hashCode());
+
+        assertEquals(ts5.hashCode(), ts6.hashCode());
+    }
+}

From 6b47b11106f10d93f7bc732476201a857da22711 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sun, 10 Jul 2016 08:36:10 +0200
Subject: [PATCH 103/263] 1.x: new fromAsync to bridge the callback world with
 the reactive (#4179)

* 1.x: new fromAsync to bridge the callback world with the reactive

* Inline requested, fix buffer/latest accounting

* Remove package qualifier
---
 src/main/java/rx/AsyncEmitter.java            |  82 ++
 src/main/java/rx/Observable.java              |  44 ++
 .../internal/operators/BackpressureUtils.java |  17 +-
 .../operators/OnSubscribeFromAsync.java       | 534 +++++++++++++
 .../operators/OnSubscribeFromAsyncTest.java   | 727 ++++++++++++++++++
 5 files changed, 1402 insertions(+), 2 deletions(-)
 create mode 100644 src/main/java/rx/AsyncEmitter.java
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeFromAsync.java
 create mode 100644 src/test/java/rx/internal/operators/OnSubscribeFromAsyncTest.java

diff --git a/src/main/java/rx/AsyncEmitter.java b/src/main/java/rx/AsyncEmitter.java
new file mode 100644
index 0000000000..6235db4f60
--- /dev/null
+++ b/src/main/java/rx/AsyncEmitter.java
@@ -0,0 +1,82 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx;
+
+import rx.annotations.Experimental;
+
+/**
+ * Abstraction over a RxJava Subscriber that allows associating
+ * a resource with it and exposes the current number of downstream
+ * requested amount.
+ * <p>
+ * The onNext, onError and onCompleted methods should be called 
+ * in a sequential manner, just like the Observer's methods. The
+ * other methods are threadsafe.
+ *
+ * @param <T> the value type to emit
+ */
+@Experimental
+public interface AsyncEmitter<T> extends Observer<T> {
+
+    /**
+     * Sets a Subscription on this emitter; any previous Subscription
+     * or Cancellation will be unsubscribed/cancelled.
+     * @param s the subscription, null is allowed
+     */
+    void setSubscription(Subscription s);
+    
+    /**
+     * Sets a Cancellable on this emitter; any previous Subscription
+     * or Cancellation will be unsubscribed/cancelled.
+     * @param c the cancellable resource, null is allowed
+     */
+    void setCancellation(Cancellable c);
+    /**
+     * The current outstanding request amount.
+     * <p>This method it threadsafe.
+     * @return the current outstanding request amount
+     */
+    long requested();
+    
+    /**
+     * A functional interface that has a single close method
+     * that can throw.
+     */
+    interface Cancellable {
+        
+        /**
+         * Cancel the action or free a resource.
+         * @throws Exception on error
+         */
+        void cancel() throws Exception;
+    }
+    
+    /**
+     * Options to handle backpressure in the emitter.
+     */
+    enum BackpressureMode {
+        NONE,
+        
+        ERROR,
+        
+        BUFFER,
+        
+        DROP,
+        
+        LATEST
+    }
+}
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 7b462abd90..7114a42e76 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -1680,6 +1680,50 @@ public static <T> Observable<T> from(T[] array) {
         return create(new OnSubscribeFromArray<T>(array));
     }
 
+    /**
+     * Provides an API (via a cold Observable) that bridges the reactive world with the callback-style,
+     * generally non-backpressured world.
+     * <p>
+     * Example:
+     * <pre><code>
+     * Observable.&lt;Event&gt;fromAsync(emitter -&gt; {
+     *     Callback listener = new Callback() {
+     *         &#64;Override
+     *         public void onEvent(Event e) {
+     *             emitter.onNext(e);
+     *             if (e.isLast()) {
+     *                 emitter.onCompleted();
+     *             }
+     *         }
+     *         
+     *         &#64;Override
+     *         public void onFailure(Exception e) {
+     *             emitter.onError(e);
+     *         }
+     *     };
+     *     
+     *     AutoCloseable c = api.someMethod(listener);
+     *     
+     *     emitter.setCancellable(c::close);
+     *     
+     * }, BackpressureMode.BUFFER);
+     * </code></pre>
+     * <p>
+     * You should call the AsyncEmitter's onNext, onError and onCompleted methods in a serialized fashion. The
+     * rest of its methods are threadsafe.
+     * 
+     * @param asyncEmitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
+     * @param backpressure the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
+     * @return the new Observable instance
+     * @see AsyncEmitter
+     * @see AsyncEmitter.BackpressureMode
+     * @see AsyncEmitter.Cancellable
+     */
+    @Experimental
+    public static <T> Observable<T> fromAsync(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) {
+        return create(new OnSubscribeFromAsync<T>(asyncEmitter, backpressure));
+    }
+    
     /**
      * Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then
      * emits the value returned from that function.
diff --git a/src/main/java/rx/internal/operators/BackpressureUtils.java b/src/main/java/rx/internal/operators/BackpressureUtils.java
index 5d63ab7c27..d627ef22b5 100644
--- a/src/main/java/rx/internal/operators/BackpressureUtils.java
+++ b/src/main/java/rx/internal/operators/BackpressureUtils.java
@@ -69,14 +69,14 @@ public static <T> long getAndAddRequest(AtomicLongFieldUpdater<T> requested, T o
     }
 
     /**
-     * Adds {@code n} to {@code requested} and returns the value prior to addition once the
+     * Adds {@code n} (not validated) to {@code requested} and returns the value prior to addition once the
      * addition is successful (uses CAS semantics). If overflows then sets
      * {@code requested} field to {@code Long.MAX_VALUE}.
      * 
      * @param requested
      *            atomic long that should be updated
      * @param n
-     *            the number of requests to add to the requested count
+     *            the number of requests to add to the requested count, positive (not validated)
      * @return requested value just prior to successful addition
      */
     public static long getAndAddRequest(AtomicLong requested, long n) {
@@ -413,4 +413,17 @@ public static long produced(AtomicLong requested, long n) {
             }
         }
     }
+    
+    /**
+     * Validates the requested amount and returns true if it is positive.
+     * @param n the requested amount
+     * @return true if n is positive
+     * @throws IllegalArgumentException if n is negative
+     */
+    public static boolean validate(long n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("n >= 0 required but it was " + n);
+        }
+        return n != 0L;
+    }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromAsync.java b/src/main/java/rx/internal/operators/OnSubscribeFromAsync.java
new file mode 100644
index 0000000000..1aa42954a1
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromAsync.java
@@ -0,0 +1,534 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import java.util.Queue;
+import java.util.concurrent.atomic.*;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.exceptions.*;
+import rx.functions.Action1;
+import rx.internal.util.RxRingBuffer;
+import rx.internal.util.atomic.SpscUnboundedAtomicArrayQueue;
+import rx.internal.util.unsafe.*;
+import rx.plugins.RxJavaHooks;
+import rx.subscriptions.SerialSubscription;
+
+public final class OnSubscribeFromAsync<T> implements OnSubscribe<T> {
+
+    final Action1<AsyncEmitter<T>> asyncEmitter;
+    
+    final AsyncEmitter.BackpressureMode backpressure;
+    
+    public OnSubscribeFromAsync(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) {
+        this.asyncEmitter = asyncEmitter;
+        this.backpressure = backpressure;
+    }
+    
+    @Override
+    public void call(Subscriber<? super T> t) {
+        BaseAsyncEmitter<T> emitter;
+        
+        switch (backpressure) {
+        case NONE: {
+            emitter = new NoneAsyncEmitter<T>(t);
+            break;
+        }
+        case ERROR: {
+            emitter = new ErrorAsyncEmitter<T>(t);
+            break;
+        }
+        case DROP: {
+            emitter = new DropAsyncEmitter<T>(t);
+            break;
+        }
+        case LATEST: {
+            emitter = new LatestAsyncEmitter<T>(t);
+            break;
+        }
+        default: {
+            emitter = new BufferAsyncEmitter<T>(t, RxRingBuffer.SIZE);
+            break;
+        }
+        }
+
+        t.add(emitter);
+        t.setProducer(emitter);
+        asyncEmitter.call(emitter);
+        
+    }
+    
+    static final class CancellableSubscription 
+    extends AtomicReference<AsyncEmitter.Cancellable>
+    implements Subscription {
+        
+        /** */
+        private static final long serialVersionUID = 5718521705281392066L;
+
+        public CancellableSubscription(AsyncEmitter.Cancellable cancellable) {
+            super(cancellable);
+        }
+        
+        @Override
+        public boolean isUnsubscribed() {
+            return get() == null;
+        }
+        
+        @Override
+        public void unsubscribe() {
+            if (get() != null) {
+                AsyncEmitter.Cancellable c = getAndSet(null);
+                if (c != null) {
+                    try {
+                        c.cancel();
+                    } catch (Exception ex) {
+                        Exceptions.throwIfFatal(ex);
+                        RxJavaHooks.onError(ex);
+                    }
+                }
+            }
+        }
+    }
+    
+    static abstract class BaseAsyncEmitter<T> 
+    extends AtomicLong
+    implements AsyncEmitter<T>, Producer, Subscription {
+        /** */
+        private static final long serialVersionUID = 7326289992464377023L;
+
+        final Subscriber<? super T> actual;
+        
+        final SerialSubscription serial;
+
+        public BaseAsyncEmitter(Subscriber<? super T> actual) {
+            this.actual = actual;
+            this.serial = new SerialSubscription();
+        }
+
+        @Override
+        public void onCompleted() {
+            if (actual.isUnsubscribed()) {
+                return;
+            }
+            try {
+                actual.onCompleted();
+            } finally {
+                serial.unsubscribe();
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            if (actual.isUnsubscribed()) {
+                return;
+            }
+            try {
+                actual.onError(e);
+            } finally {
+                serial.unsubscribe();
+            }
+        }
+
+        @Override
+        public final void unsubscribe() {
+            serial.unsubscribe();
+            onUnsubscribed();
+        }
+        
+        void onUnsubscribed() {
+            // default is no-op
+        }
+
+        @Override
+        public final boolean isUnsubscribed() {
+            return serial.isUnsubscribed();
+        }
+
+        @Override
+        public final void request(long n) {
+            if (BackpressureUtils.validate(n)) {
+                BackpressureUtils.getAndAddRequest(this, n);
+                onRequested();
+            }
+        }
+
+        void onRequested() {
+            // default is no-op
+        }
+        
+        @Override
+        public final void setSubscription(Subscription s) {
+            serial.set(s);
+        }
+
+        @Override
+        public final void setCancellation(AsyncEmitter.Cancellable c) {
+            setSubscription(new CancellableSubscription(c));
+        }
+
+        @Override
+        public final long requested() {
+            return get();
+        }
+    }
+    
+    static final class NoneAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 3776720187248809713L;
+
+        public NoneAsyncEmitter(Subscriber<? super T> actual) {
+            super(actual);
+        }
+
+        @Override
+        public void onNext(T t) {
+            if (actual.isUnsubscribed()) {
+                return;
+            }
+
+            actual.onNext(t);
+            
+            for (;;) {
+                long r = get();
+                if (r == 0L || compareAndSet(r, r - 1)) {
+                    return;
+                }
+            }
+        }
+
+    }
+    
+    static abstract class NoOverflowBaseAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 4127754106204442833L;
+
+        public NoOverflowBaseAsyncEmitter(Subscriber<? super T> actual) {
+            super(actual);
+        }
+
+        @Override
+        public final void onNext(T t) {
+            if (actual.isUnsubscribed()) {
+                return;
+            }
+
+            if (get() != 0) {
+                actual.onNext(t);
+                BackpressureUtils.produced(this, 1);
+            } else {
+                onOverflow();
+            }
+        }
+        
+        abstract void onOverflow();
+    }
+    
+    static final class DropAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 8360058422307496563L;
+
+        public DropAsyncEmitter(Subscriber<? super T> actual) {
+            super(actual);
+        }
+
+        @Override
+        void onOverflow() {
+            // nothing to do
+        }
+        
+    }
+
+    static final class ErrorAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 338953216916120960L;
+
+        public ErrorAsyncEmitter(Subscriber<? super T> actual) {
+            super(actual);
+        }
+
+        @Override
+        void onOverflow() {
+            onError(new MissingBackpressureException("fromAsync: could not emit value due to lack of requests"));
+        }
+        
+    }
+    
+    static final class BufferAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 2427151001689639875L;
+
+        final Queue<Object> queue;
+        
+        Throwable error;
+        volatile boolean done;
+        
+        final AtomicInteger wip;
+        
+        final NotificationLite<T> nl;
+        
+        public BufferAsyncEmitter(Subscriber<? super T> actual, int capacityHint) {
+            super(actual);
+            this.queue = UnsafeAccess.isUnsafeAvailable() 
+                    ? new SpscUnboundedArrayQueue<Object>(capacityHint)
+                    : new SpscUnboundedAtomicArrayQueue<Object>(capacityHint);
+            this.wip = new AtomicInteger();
+            this.nl = NotificationLite.instance();
+        }
+
+        @Override
+        public void onNext(T t) {
+            queue.offer(nl.next(t));
+            drain();
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            error = e;
+            done = true;
+            drain();
+        }
+
+        @Override
+        public void onCompleted() {
+            done = true;
+            drain();
+        }
+        
+        @Override
+        void onRequested() {
+            drain();
+        }
+
+        @Override
+        void onUnsubscribed() {
+            if (wip.getAndIncrement() == 0) {
+                queue.clear();
+            }
+        }
+        
+        void drain() {
+            if (wip.getAndIncrement() != 0) {
+                return;
+            }
+            
+            int missed = 1;
+            final Subscriber<? super T> a = actual;
+            final Queue<Object> q = queue;
+            
+            for (;;) {
+                long r = get();
+                long e = 0L;
+                
+                while (e != r) {
+                    if (a.isUnsubscribed()) {
+                        q.clear();
+                        return;
+                    }
+                    
+                    boolean d = done;
+                    
+                    Object o = q.poll();
+                    
+                    boolean empty = o == null;
+                    
+                    if (d && empty) {
+                        Throwable ex = error;
+                        if (ex != null) {
+                            super.onError(ex);
+                        } else {
+                            super.onCompleted();
+                        }
+                        return;
+                    }
+                    
+                    if (empty) {
+                        break;
+                    }
+                    
+                    a.onNext(nl.getValue(o));
+                    
+                    e++;
+                }
+                
+                if (e == r) {
+                    if (a.isUnsubscribed()) {
+                        q.clear();
+                        return;
+                    }
+                    
+                    boolean d = done;
+                    
+                    boolean empty = q.isEmpty();
+                    
+                    if (d && empty) {
+                        Throwable ex = error;
+                        if (ex != null) {
+                            super.onError(ex);
+                        } else {
+                            super.onCompleted();
+                        }
+                        return;
+                    }
+                }
+                
+                if (e != 0) {
+                    BackpressureUtils.produced(this, e);
+                }
+                
+                missed = wip.addAndGet(-missed);
+                if (missed == 0) {
+                    break;
+                }
+            }
+        }
+    }
+
+    static final class LatestAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 4023437720691792495L;
+
+        final AtomicReference<Object> queue;
+
+        Throwable error;
+        volatile boolean done;
+        
+        final AtomicInteger wip;
+        
+        final NotificationLite<T> nl;
+        
+        public LatestAsyncEmitter(Subscriber<? super T> actual) {
+            super(actual);
+            this.queue = new AtomicReference<Object>();
+            this.wip = new AtomicInteger();
+            this.nl = NotificationLite.instance();
+        }
+
+        @Override
+        public void onNext(T t) {
+            queue.set(nl.next(t));
+            drain();
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            error = e;
+            done = true;
+            drain();
+        }
+
+        @Override
+        public void onCompleted() {
+            done = true;
+            drain();
+        }
+        
+        @Override
+        void onRequested() {
+            drain();
+        }
+
+        @Override
+        void onUnsubscribed() {
+            if (wip.getAndIncrement() == 0) {
+                queue.lazySet(null);
+            }
+        }
+        
+        void drain() {
+            if (wip.getAndIncrement() != 0) {
+                return;
+            }
+            
+            int missed = 1;
+            final Subscriber<? super T> a = actual;
+            final AtomicReference<Object> q = queue;
+            
+            for (;;) {
+                long r = get();
+                long e = 0L;
+                
+                while (e != r) {
+                    if (a.isUnsubscribed()) {
+                        q.lazySet(null);
+                        return;
+                    }
+                    
+                    boolean d = done;
+                    
+                    Object o = q.getAndSet(null);
+                    
+                    boolean empty = o == null;
+                    
+                    if (d && empty) {
+                        Throwable ex = error;
+                        if (ex != null) {
+                            super.onError(ex);
+                        } else {
+                            super.onCompleted();
+                        }
+                        return;
+                    }
+                    
+                    if (empty) {
+                        break;
+                    }
+                    
+                    a.onNext(nl.getValue(o));
+                    
+                    e++;
+                }
+                
+                if (e == r) {
+                    if (a.isUnsubscribed()) {
+                        q.lazySet(null);
+                        return;
+                    }
+                    
+                    boolean d = done;
+                    
+                    boolean empty = q.get() == null;
+                    
+                    if (d && empty) {
+                        Throwable ex = error;
+                        if (ex != null) {
+                            super.onError(ex);
+                        } else {
+                            super.onCompleted();
+                        }
+                        return;
+                    }
+                }
+                
+                if (e != 0) {
+                    BackpressureUtils.produced(this, e);
+                }
+                
+                missed = wip.addAndGet(-missed);
+                if (missed == 0) {
+                    break;
+                }
+            }
+        }
+    }
+
+}
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromAsyncTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromAsyncTest.java
new file mode 100644
index 0000000000..26dd1f75f6
--- /dev/null
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromAsyncTest.java
@@ -0,0 +1,727 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import org.junit.*;
+
+import rx.*;
+import rx.exceptions.*;
+import rx.functions.Action1;
+import rx.observers.TestSubscriber;
+import rx.subjects.PublishSubject;
+
+public class OnSubscribeFromAsyncTest {
+
+    PublishAsyncEmitter source;
+
+    PublishAsyncEmitterNoCancel sourceNoCancel;
+
+    TestSubscriber<Integer> ts;
+    
+    @Before
+    public void before() {
+        source = new PublishAsyncEmitter();
+        sourceNoCancel = new PublishAsyncEmitterNoCancel();
+        ts = TestSubscriber.create(0L);
+    }
+    
+    @Test
+    public void normalBuffered() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+        
+        ts.requestMore(1);
+        
+        ts.assertValue(1);
+        
+        Assert.assertEquals(0, source.requested());
+        
+        ts.requestMore(1);
+        
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void normalDrop() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+        
+        source.onNext(1);
+
+        ts.requestMore(1);
+
+        source.onNext(2);
+        source.onCompleted();
+        
+        ts.assertValues(2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void normalLatest() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        
+        source.onNext(1);
+
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.requestMore(1);
+
+        ts.assertValues(2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void normalNone() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void normalNoneRequested() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        ts.requestMore(2);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+
+    @Test
+    public void normalError() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.assertNoValues();
+        ts.assertError(MissingBackpressureException.class);
+        ts.assertNotCompleted();
+        
+        Assert.assertEquals("fromAsync: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+    }
+
+    @Test
+    public void errorBuffered() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertValue(1);
+        
+        ts.requestMore(1);
+        
+        ts.assertValues(1, 2);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void errorLatest() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertValues(2);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void errorNone() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertValues(1, 2);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedBuffer() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        ts.unsubscribe();
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedLatest() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        ts.unsubscribe();
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedError() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+        ts.unsubscribe();
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedDrop() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+        ts.unsubscribe();
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNone() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        ts.unsubscribe();
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNoCancelBuffer() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        ts.unsubscribe();
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNoCancelLatest() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        ts.unsubscribe();
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNoCancelError() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+        ts.unsubscribe();
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNoCancelDrop() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+        ts.unsubscribe();
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNoCancelNone() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        ts.unsubscribe();
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onError(new TestException());
+        
+        ts.requestMore(1);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void deferredRequest() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void take() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void takeOne() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
+        ts.requestMore(2);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+        
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void requestExact() {
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        ts.requestMore(2);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+        
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void takeNoCancel() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onCompleted();
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void takeOneNoCancel() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
+        ts.requestMore(2);
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onCompleted();
+        
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void unsubscribeNoCancel() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        ts.requestMore(2);
+        
+        sourceNoCancel.onNext(1);
+
+        ts.unsubscribe();
+        
+        sourceNoCancel.onNext(2);
+        
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+
+    @Test
+    public void unsubscribeInline() {
+        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                unsubscribe();
+            }
+        };
+        
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
+        
+        sourceNoCancel.onNext(1);
+        
+        ts1.assertValues(1);
+        ts1.assertNoErrors();
+        ts1.assertNotCompleted();
+    }
+
+    @Test
+    public void completeInline() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onCompleted();
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void errorInline() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onError(new TestException());
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void requestInline() {
+        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1) {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                requestMore(1);
+            }
+        };
+        
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        
+        ts1.assertValues(1, 2);
+        ts1.assertNoErrors();
+        ts1.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribeInlineLatest() {
+        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                unsubscribe();
+            }
+        };
+        
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+        
+        sourceNoCancel.onNext(1);
+        
+        ts1.assertValues(1);
+        ts1.assertNoErrors();
+        ts1.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribeInlineExactLatest() {
+        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1L) {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                unsubscribe();
+            }
+        };
+        
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+        
+        sourceNoCancel.onNext(1);
+        
+        ts1.assertValues(1);
+        ts1.assertNoErrors();
+        ts1.assertNotCompleted();
+    }
+
+    @Test
+    public void completeInlineLatest() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onCompleted();
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void completeInlineExactLatest() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onCompleted();
+        
+        ts.requestMore(1);
+        
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void errorInlineLatest() {
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onError(new TestException());
+        
+        ts.requestMore(2);
+        
+        ts.assertValues(1);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void requestInlineLatest() {
+        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1) {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                requestMore(1);
+            }
+        };
+        
+        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+        
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        
+        ts1.assertValues(1, 2);
+        ts1.assertNoErrors();
+        ts1.assertNotCompleted();
+    }
+    
+    static final class PublishAsyncEmitter implements Action1<AsyncEmitter<Integer>>, Observer<Integer> {
+        
+        final PublishSubject<Integer> subject;
+        
+        AsyncEmitter<Integer> current;
+        
+        public PublishAsyncEmitter() {
+            this.subject = PublishSubject.create();
+        }
+        
+        long requested() {
+            return current.requested();
+        }
+        
+        @Override
+        public void call(final AsyncEmitter<Integer> t) {
+
+            this.current = t;
+            
+            final Subscription s = subject.subscribe(new Observer<Integer>() {
+
+                @Override
+                public void onCompleted() {
+                    t.onCompleted();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    t.onError(e);
+                }
+
+                @Override
+                public void onNext(Integer v) {
+                    t.onNext(v);
+                }
+                
+            });
+            
+            t.setCancellation(new AsyncEmitter.Cancellable() {
+                @Override
+                public void cancel() throws Exception {
+                    s.unsubscribe();
+                }
+            });;
+        }
+        
+        @Override
+        public void onNext(Integer t) {
+            subject.onNext(t);
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            subject.onError(e);
+        }
+        
+        @Override
+        public void onCompleted() {
+            subject.onCompleted();
+        }
+    }
+    
+    static final class PublishAsyncEmitterNoCancel implements Action1<AsyncEmitter<Integer>>, Observer<Integer> {
+        
+        final PublishSubject<Integer> subject;
+        
+        public PublishAsyncEmitterNoCancel() {
+            this.subject = PublishSubject.create();
+        }
+        
+        @Override
+        public void call(final AsyncEmitter<Integer> t) {
+
+            subject.subscribe(new Observer<Integer>() {
+
+                @Override
+                public void onCompleted() {
+                    t.onCompleted();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    t.onError(e);
+                }
+
+                @Override
+                public void onNext(Integer v) {
+                    t.onNext(v);
+                }
+                
+            });
+        }
+        
+        @Override
+        public void onNext(Integer t) {
+            subject.onNext(t);
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            subject.onError(e);
+        }
+        
+        @Override
+        public void onCompleted() {
+            subject.onCompleted();
+        }
+    }
+
+}

From 91eeea0e83de3ba2378d08cc96d5909623ecc8d9 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sun, 10 Jul 2016 08:36:37 +0200
Subject: [PATCH 104/263] 1.x: allow customizing
 GenericScheduledExecutorService via RxJavaHooks (#4173)

* 1.x: allow customizing GenericScheduledExecutorService via RxJavaHooks

* Had to make Schedulers.start public otherwise this wouldn't work

* onGenericScheduledExecutorService is null by default
---
 .../GenericScheduledExecutorService.java      |  6 +--
 ...enericScheduledExecutorServiceFactory.java | 39 +++++++++++++++
 src/main/java/rx/plugins/RxJavaHooks.java     | 37 ++++++++++++++-
 src/main/java/rx/schedulers/Schedulers.java   |  2 +-
 src/test/java/rx/plugins/RxJavaHooksTest.java | 13 ++++-
 .../GenericScheduledExecutorServiceTest.java  | 47 +++++++++++++++++++
 6 files changed, 136 insertions(+), 8 deletions(-)
 create mode 100644 src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
 create mode 100644 src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java

diff --git a/src/main/java/rx/internal/schedulers/GenericScheduledExecutorService.java b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorService.java
index 3bc60f076b..9a22373d4d 100644
--- a/src/main/java/rx/internal/schedulers/GenericScheduledExecutorService.java
+++ b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorService.java
@@ -19,7 +19,6 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Scheduler;
-import rx.internal.util.RxThreadFactory;
 
 /**
  * A default {@link ScheduledExecutorService} that can be used for scheduling actions when a {@link Scheduler} implementation doesn't have that ability.
@@ -32,9 +31,6 @@
  */
 public final class GenericScheduledExecutorService implements SchedulerLifecycle {
 
-    private static final String THREAD_NAME_PREFIX = "RxScheduledExecutorPool-";
-    private static final RxThreadFactory THREAD_FACTORY = new RxThreadFactory(THREAD_NAME_PREFIX);
-
     private static final ScheduledExecutorService[] NONE = new ScheduledExecutorService[0];
 
     private static final ScheduledExecutorService SHUTDOWN;
@@ -72,7 +68,7 @@ public void start() {
         
         ScheduledExecutorService[] execs = new ScheduledExecutorService[count];
         for (int i = 0; i < count; i++) {
-            execs[i] = Executors.newScheduledThreadPool(1, THREAD_FACTORY);
+            execs[i] = GenericScheduledExecutorServiceFactory.create();
         }
         if (executor.compareAndSet(NONE, execs)) {
             for (ScheduledExecutorService exec : execs) {
diff --git a/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
new file mode 100644
index 0000000000..c0ea18061b
--- /dev/null
+++ b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
@@ -0,0 +1,39 @@
+package rx.internal.schedulers;
+
+import java.util.concurrent.*;
+
+import rx.functions.Func0;
+import rx.internal.util.RxThreadFactory;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Utility class to create the individual ScheduledExecutorService instances for
+ * the GenericScheduledExecutorService class.
+ */
+enum GenericScheduledExecutorServiceFactory {
+    ;
+    
+    static final String THREAD_NAME_PREFIX = "RxScheduledExecutorPool-";
+    static final RxThreadFactory THREAD_FACTORY = new RxThreadFactory(THREAD_NAME_PREFIX);
+
+    static ThreadFactory threadFactory() {
+        return THREAD_FACTORY;
+    }
+    
+    /**
+     * Creates a ScheduledExecutorService (either the default or given by a hook).
+     * @return the SchuduledExecutorService created.
+     */
+    public static ScheduledExecutorService create() {
+        Func0<? extends ScheduledExecutorService> f = RxJavaHooks.getOnGenericScheduledExecutorService();
+        if (f == null) {
+            return createDefault();
+        }
+        return f.call();
+    }
+    
+    
+    static ScheduledExecutorService createDefault() {
+        return Executors.newScheduledThreadPool(1, threadFactory());
+    }
+}
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index b68e01c287..70268c4c14 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -16,6 +16,7 @@
 package rx.plugins;
 
 import java.lang.Thread.UncaughtExceptionHandler;
+import java.util.concurrent.ScheduledExecutorService;
 
 import rx.*;
 import rx.Completable.*;
@@ -67,6 +68,8 @@ public final class RxJavaHooks {
     static volatile Func1<Subscription, Subscription> onObservableReturn;
 
     static volatile Func1<Subscription, Subscription> onSingleReturn;
+    
+    static volatile Func0<? extends ScheduledExecutorService> onGenericScheduledExecutorService;
 
     static volatile Func1<Throwable, Throwable> onObservableSubscribeError;
 
@@ -230,6 +233,7 @@ public static void reset() {
         onComputationScheduler = null;
         onIOScheduler = null;
         onNewThreadScheduler = null;
+        onGenericScheduledExecutorService = null;
     }
 
     /**
@@ -265,8 +269,9 @@ public static void clear() {
         onComputationScheduler = null;
         onIOScheduler = null;
         onNewThreadScheduler = null;
-        
+
         onScheduleAction = null;
+        onGenericScheduledExecutorService = null;
     }
 
     /**
@@ -1195,4 +1200,34 @@ public CompletableOnSubscribe call(CompletableOnSubscribe f) {
         };
 
     }
+    /**
+     * Sets the hook function for returning a ScheduledExecutorService used
+     * by the GenericScheduledExecutorService for background tasks.
+     * <p>
+     * This operation is threadsafe.
+     * <p>
+     * Calling with a {@code null} parameter restores the default behavior:
+     * create the default with {@link java.util.concurrent.Executors#newScheduledThreadPool(int, java.util.concurrent.ThreadFactory)}.
+     * <p>
+     * For the changes to take effect, the Schedulers has to be restarted.
+     * @param factory the supplier that is called when the GenericScheduledExecutorService
+     * is (re)started
+     */
+    public static void setOnGenericScheduledExecutorService(Func0<? extends ScheduledExecutorService> factory) {
+        if (lockdown) {
+            return;
+        }
+        onGenericScheduledExecutorService = factory;
+    }
+    
+    /**
+     * Returns the current factory for creating ScheduledExecutorServices in
+     * GenericScheduledExecutorService utility.
+     * <p>
+     * This operation is threadsafe.
+     * @return the current factory function
+     */
+    public static Func0<? extends ScheduledExecutorService> getOnGenericScheduledExecutorService() {
+        return onGenericScheduledExecutorService;
+    }
 }
diff --git a/src/main/java/rx/schedulers/Schedulers.java b/src/main/java/rx/schedulers/Schedulers.java
index a24504f94d..8df2dacf99 100644
--- a/src/main/java/rx/schedulers/Schedulers.java
+++ b/src/main/java/rx/schedulers/Schedulers.java
@@ -178,7 +178,7 @@ public static void reset() {
      * Starts those standard Schedulers which support the SchedulerLifecycle interface.
      * <p>The operation is idempotent and threadsafe.
      */
-    /* public test only */ static void start() {
+    public static void start() {
         Schedulers s = getInstance();
         
         s.startInstance();
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index f13c8514b7..9209228124 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -173,6 +173,12 @@ public void lockdown() throws Exception {
         try {
             assertTrue(RxJavaHooks.isLockdown());
             Action1 a1 = Actions.empty();
+            Func0 f0 = new Func0() {
+                @Override
+                public Object call() {
+                    return null;
+                }
+            };
             Func1 f1 = UtilityFunctions.identity();
             Func2 f2 = new Func2() {
                 @Override
@@ -188,6 +194,9 @@ public Object call(Object t1, Object t2) {
                     
                     Object before = getter.invoke(null);
                     
+                    if (m.getParameterTypes()[0].isAssignableFrom(Func0.class)) {
+                        m.invoke(null, f0);
+                    } else
                     if (m.getParameterTypes()[0].isAssignableFrom(Func1.class)) {
                         m.invoke(null, f1);
                     } else
@@ -640,7 +649,9 @@ public void clear() throws Exception {
         }
 
         for (Method m : RxJavaHooks.class.getMethods()) {
-            if (m.getName().startsWith("getOn") && !m.getName().endsWith("Scheduler")) {
+            if (m.getName().startsWith("getOn") 
+                    && !m.getName().endsWith("Scheduler")
+                    && !m.getName().contains("GenericScheduledExecutorService")) {
                 assertNotNull(m.toString(), m.invoke(null));
             }
         }
diff --git a/src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java b/src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java
new file mode 100644
index 0000000000..6a92227bf5
--- /dev/null
+++ b/src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java
@@ -0,0 +1,47 @@
+package rx.schedulers;
+
+import java.util.concurrent.*;
+
+import org.junit.*;
+
+import rx.functions.Func0;
+import rx.internal.schedulers.GenericScheduledExecutorService;
+import rx.plugins.RxJavaHooks;
+
+public class GenericScheduledExecutorServiceTest {
+
+    @Test
+    public void genericScheduledExecutorServiceHook() {
+        // make sure the class is initialized
+        Assert.assertNotNull(GenericScheduledExecutorService.class);
+        
+        final ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
+        try {
+            
+            RxJavaHooks.setOnGenericScheduledExecutorService(new Func0<ScheduledExecutorService>() {
+                @Override
+                public ScheduledExecutorService call() {
+                    return exec;
+                }
+            });
+            
+            Schedulers.shutdown();
+            Schedulers.start();
+            
+            Assert.assertSame(exec, GenericScheduledExecutorService.getInstance());
+            
+            RxJavaHooks.setOnGenericScheduledExecutorService(null);
+            
+            Schedulers.shutdown();
+            // start() is package private so had to move this test here
+            Schedulers.start();
+
+            Assert.assertNotSame(exec, GenericScheduledExecutorService.getInstance());
+
+        } finally {
+            RxJavaHooks.reset();
+            exec.shutdownNow();
+        }
+        
+    }
+}

From 0d76f544eb0f4197c0dc376c6a7c8948a7ddce71 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sun, 10 Jul 2016 08:54:23 +0200
Subject: [PATCH 105/263] Release 1.1.7 changes.md update (#4184)

* Release 1.1.7 changes.md update

* Mention last 2 PRs merged
---
 CHANGES.md | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index efc3a614d5..3c5370b059 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,75 @@
 # RxJava Releases #
 
+### Version 1.1.7 - July 10, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.7%7C))
+
+This release has several documentation fixes (`AsyncSubject`, `doOnEach`, `cache`, `scan`, `reduce`, backpressure descriptions) and internal cleanups based on tool feedback (code-coverage and PMD).
+
+**Warning: behavior change in the time-bound `replay()` operator**: the aging of the values continues after the termination of the source and thus late subscribers no longer get old data. For example, a given `just(1).replay(1, TimeUnit.MINUTE)` a subscriber subscribing after 2 minutes won't get `1` but only `onCompleted`.
+
+**Warning: behavior change in `timestamp()` and `timeInterval()` (no arguments) operators**: they now take timing information from the `computation` scheduler instead of the `immediate` scheduler. This change now allows hooking these operators' time source.
+
+**Warning**: the parameter order of `Completable.subscribe(onError, onComplete)` has been changed to `Completable.subscribe(onComplete, onError)` to better match the callback order in the other base reactive classes, namely the most significant signal comes first (`Observer.onNext`, `SingleSubscriber.onSuccess`, and now `CompletableSubscriber.onCompleted`).
+
+#### The new RxJavaHooks API
+
+PR #4007 introduced a new way of hooking into the lifecycle of the base reactive types (`Observable`, `Single`, `Completable`) and the `Scheduler`s. The original `RxJavaPlugins`' design was too much focused on class-initialization time hooking and didn't properly allow hooking up different behavior after that. There is a `reset()` available on it but sometimes that doesn't work as expected.
+
+The new class `rx.plugins.RxJavaHooks` allows changing the hooks at runtime, allowing tests to temporarily hook onto an internal behavior and then un-hook once the test completed.
+
+```java
+RxJavaHooks.setOnObservableCreate(s -> {
+   System.out.println("Observable created");
+   return s;
+});
+
+Observable.just(1).subscribe(System.out::println);
+
+RxJavaHooks.reset();
+// or
+RxJavaHooks.setOnObservableCreate(null);
+```
+
+It is now also possible to override what `Scheduler`s the `Schedulers.computation()`, `.io()` and `.newThread()` returns without the need to fiddle with `Schedulers`' own reset behavior:
+
+```java
+RxJavaHooks.setOnComputationScheduler(current -> Schedulers.immediate());
+
+Observable.just(1).subscribeOn(Schedulers.computation())
+.subscribe(v -> System.out.println(Thread.currentThread()));
+``` 
+
+By default, all `RxJavaHooks` delegate to the original `RxJavaPlugins` callbacks so if you have hooks the old way, they still work. `RxJavaHooks.reset()` resets to this delegation and `RxJavaHooks.clear()` clears all hooks (i.e., everything becomes a pass-through hook).
+
+#### API enhancements
+
+  - [Pull 3966](https://github.com/ReactiveX/RxJava/pull/3966): Add multi-other `withLatestFrom` operators.
+  - [Pull 3720](https://github.com/ReactiveX/RxJava/pull/3720): Add vararg of `Subscription`s to composite subscription.
+  - [Pull 4034](https://github.com/ReactiveX/RxJava/pull/4034): `distinctUntilChanged` with direct value comparator - alternative.
+  - [Pull 4036](https://github.com/ReactiveX/RxJava/pull/4036): Added zip function with Observable array.
+  - [Pull 4020](https://github.com/ReactiveX/RxJava/pull/4020): Add `AsyncCompletableSubscriber` that exposes `unsubscribe()`.
+  - [Pull 4011](https://github.com/ReactiveX/RxJava/pull/4011): Deprecate `TestObserver`, enhance `TestSubscriber` a bit.
+  - [Pull 4007](https://github.com/ReactiveX/RxJava/pull/4007): new hook management proposal
+  - [Pull 4173](https://github.com/ReactiveX/RxJava/pull/4173): allow customizing GenericScheduledExecutorService via RxJavaHooks
+  - [Pull 3931](https://github.com/ReactiveX/RxJava/pull/3931): add `groupBy` overload with `evictingMapFactory`
+  - [Pull 4140](https://github.com/ReactiveX/RxJava/pull/4140): Change `Completable.subscribe(onError, onComplete)` to `(onComplete, onError)`
+  - [Pull 4154](https://github.com/ReactiveX/RxJava/pull/4154): Ability to create custom schedulers with behavior based on composing operators via `Scheduler.when`.
+  - [Pull 4179](https://github.com/ReactiveX/RxJava/pull/4179): New `fromAsync` to bridge the callback world with the reactive.
+  
+#### API deprecations
+
+  - [Pull 4011](https://github.com/ReactiveX/RxJava/pull/4011): Deprecate `TestObserver`, enhance `TestSubscriber` a bit.
+  - [Pull 4007](https://github.com/ReactiveX/RxJava/pull/4007): new hook management proposal (deprecates some `RxJavaPlugins` methods).
+
+#### Performance enhancements
+
+  - [Pull 4097](https://github.com/ReactiveX/RxJava/pull/4097): update `map()` and `filter()` to implement `OnSubscribe` directly.
+  - [Pull 4176](https://github.com/ReactiveX/RxJava/pull/4176): Optimize collect, reduce and takeLast(1)
+
+#### Bugfixes
+
+  - [Pull 4027](https://github.com/ReactiveX/RxJava/pull/4027): fix `Completable.onErrorComplete(Func1)` not relaying function crash.
+  - [Pull 4051](https://github.com/ReactiveX/RxJava/pull/4051): fix `ReplaySubject` anomaly around caughtUp by disabling that optimization.
+
 ### Version 1.1.6 - June 15, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.6%7C))
 
 #### API enhancements

From 76182a7e4d939b7d83b02e93abe36ec7d2c16788 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sun, 10 Jul 2016 13:39:00 +0200
Subject: [PATCH 106/263] Move status icons to top, add maven version badge.
 (#4187)

---
 README.md | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index da3619c8df..fc35e066d8 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,9 @@
 # RxJava: Reactive Extensions for the JVM
 
+<a href='https://travis-ci.org/ReactiveX/RxJava/builds'><img src='https://travis-ci.org/ReactiveX/RxJava.svg?branch=1.x'></a>
+[![codecov.io](http://codecov.io/github/ReactiveX/RxJava/coverage.svg?branch=1.x)](http://codecov.io/github/ReactiveX/RxJava?branch=1.x)
+[![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.reactivex/rxjava/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.reactivex/rxjava)
+
 RxJava is a Java VM implementation of [Reactive Extensions](http://reactivex.io): a library for composing asynchronous and event-based programs by using observable sequences.
 
 It extends the [observer pattern](http://en.wikipedia.org/wiki/Observer_pattern) to support sequences of data/events and adds operators that allow you to compose sequences together declaratively while abstracting away concerns about things like low-level threading, synchronization, thread-safety and concurrent data structures.
@@ -15,12 +19,6 @@ It extends the [observer pattern](http://en.wikipedia.org/wiki/Observer_pattern)
 
 Learn more about RxJava on the <a href="https://github.com/ReactiveX/RxJava/wiki">Wiki Home</a>.
 
-## Master Build Status
-
-<a href='https://travis-ci.org/ReactiveX/RxJava/builds'><img src='https://travis-ci.org/ReactiveX/RxJava.svg?branch=1.x'></a>
-[![codecov.io](http://codecov.io/github/ReactiveX/RxJava/coverage.svg?branch=1.x)](http://codecov.io/github/ReactiveX/RxJava?branch=1.x)
-
-
 ## Communication
 
 - Google Group: [RxJava](http://groups.google.com/d/forum/rxjava)

From 6b72d8ac246e2c071e6f7c45c946f6886c3a5c6b Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sun, 10 Jul 2016 16:36:49 +0200
Subject: [PATCH 107/263] 1.x: add missing headers, add SuppressWarnings
 (#4188)

---
 src/main/java/rx/Scheduler.java                  |  1 +
 .../GenericScheduledExecutorServiceFactory.java  | 16 ++++++++++++++++
 .../producers/SingleDelayedProducerTest.java     | 16 ++++++++++++++++
 .../internal/producers/SingleProducerTest.java   | 16 ++++++++++++++++
 .../GenericScheduledExecutorServiceTest.java     | 16 ++++++++++++++++
 5 files changed, 65 insertions(+)

diff --git a/src/main/java/rx/Scheduler.java b/src/main/java/rx/Scheduler.java
index f1b8a0e28a..756963e66f 100644
--- a/src/main/java/rx/Scheduler.java
+++ b/src/main/java/rx/Scheduler.java
@@ -256,6 +256,7 @@ public long now() {
 	 * @param combine
 	 * @return
 	 */
+    @SuppressWarnings("unchecked")
     @Experimental
 	public <S extends Scheduler & Subscription> S when(Func1<Observable<Observable<Completable>>, Completable> combine) {
 		return (S) new SchedulerWhen(combine, this);
diff --git a/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
index c0ea18061b..ce4dd8b5b2 100644
--- a/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
+++ b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.schedulers;
 
 import java.util.concurrent.*;
diff --git a/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java b/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
index d40387b360..9411b9909e 100644
--- a/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
+++ b/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.producers;
 
 import java.util.concurrent.*;
diff --git a/src/test/java/rx/internal/producers/SingleProducerTest.java b/src/test/java/rx/internal/producers/SingleProducerTest.java
index faac28ba4d..48cda1ef16 100644
--- a/src/test/java/rx/internal/producers/SingleProducerTest.java
+++ b/src/test/java/rx/internal/producers/SingleProducerTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.producers;
 
 import org.junit.*;
diff --git a/src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java b/src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java
index 6a92227bf5..93303ce87d 100644
--- a/src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java
+++ b/src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.schedulers;
 
 import java.util.concurrent.*;

From 65c7070c2dae6b27cafb2c37f50b884478ba3949 Mon Sep 17 00:00:00 2001
From: Santiago Castro <bryant@montevideo.com.uy>
Date: Mon, 11 Jul 2016 11:12:00 -0300
Subject: [PATCH 108/263] Fix grammar error in RxJavaHooks javadocs (#4191)

---
 src/main/java/rx/plugins/RxJavaHooks.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index 70268c4c14..cef9a8f6fb 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -275,7 +275,7 @@ public static void clear() {
     }
 
     /**
-     * Prevents changing a hooks.
+     * Prevents changing the hooks.
      */
     public static void lockdown() {
         lockdown = true;

From 4d5515a370b51db381d01f88a4704a4072c727eb Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 20 Jul 2016 23:04:10 +0200
Subject: [PATCH 109/263] 1.x: merge/flatMap to keep scalar/inner element
 relative order (#4209)

* 1.x: merge/flatMap to keep scalar/inner element relative order

* Read the queue references once
---
 .../rx/internal/operators/OperatorMerge.java  | 20 +++++++--
 .../internal/operators/OperatorMergeTest.java | 41 +++++++++++++++++++
 2 files changed, 57 insertions(+), 4 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorMerge.java b/src/main/java/rx/internal/operators/OperatorMerge.java
index 71d74713bf..a5d92a33ae 100644
--- a/src/main/java/rx/internal/operators/OperatorMerge.java
+++ b/src/main/java/rx/internal/operators/OperatorMerge.java
@@ -352,9 +352,16 @@ void tryEmit(InnerSubscriber<T> subscriber, T value) {
                 }
             }
             if (success) {
-                emitScalar(subscriber, value, r);
+                RxRingBuffer subscriberQueue = subscriber.queue;
+                if (subscriberQueue == null || subscriberQueue.isEmpty()) {
+                    emitScalar(subscriber, value, r);
+                } else {
+                    queueScalar(subscriber, value);
+                    emitLoop();
+                }
             } else {
                 queueScalar(subscriber, value);
+                emit();
             }
         }
 
@@ -383,7 +390,6 @@ protected void queueScalar(InnerSubscriber<T> subscriber, T value) {
                 }
                 return;
             }
-            emit();
         }
 
         protected void emitScalar(InnerSubscriber<T> subscriber, T value, long r) {
@@ -460,9 +466,16 @@ void tryEmit(T value) {
                 }
             }
             if (success) {
-                emitScalar(value, r);
+                Queue<Object> mainQueue = queue;
+                if (mainQueue == null || mainQueue.isEmpty()) {
+                    emitScalar(value, r);
+                } else {
+                    queueScalar(value);
+                    emitLoop();
+                }
             } else {
                 queueScalar(value);
+                emit();
             }
         }
 
@@ -495,7 +508,6 @@ protected void queueScalar(T value) {
                 onError(OnErrorThrowable.addValueAsLastCause(new MissingBackpressureException(), value));
                 return;
             }
-            emit();
         }
 
         protected void emitScalar(T value, long r) {
diff --git a/src/test/java/rx/internal/operators/OperatorMergeTest.java b/src/test/java/rx/internal/operators/OperatorMergeTest.java
index 8f6e2a2aa2..76c7b43333 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeTest.java
@@ -34,6 +34,7 @@
 import rx.Observer;
 import rx.Scheduler.Worker;
 import rx.functions.*;
+import rx.internal.operators.OperatorMerge.*;
 import rx.internal.util.*;
 import rx.observers.TestSubscriber;
 import rx.schedulers.*;
@@ -1498,4 +1499,44 @@ public void flatMapMaxConcurrentJustRange() {
         ts.assertNoErrors();
         ts.assertCompleted();
     }
+    
+    @Test
+    public void noInnerReordering() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        MergeSubscriber<Integer> ms = new MergeSubscriber<Integer>(ts, false, 128);
+        ms.producer = new MergeProducer<Integer>(ms);
+        ts.setProducer(ms.producer);
+
+        PublishSubject<Integer> ps = PublishSubject.create();
+
+        ms.onNext(ps);
+        
+        ps.onNext(1);
+        
+        BackpressureUtils.getAndAddRequest(ms.producer, 2);
+        
+        ps.onNext(2);
+        
+        ms.emit();
+        
+        ts.assertValues(1, 2);
+    }
+    
+    @Test
+    public void noOuterScalarReordering() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        MergeSubscriber<Integer> ms = new MergeSubscriber<Integer>(ts, false, 128);
+        ms.producer = new MergeProducer<Integer>(ms);
+        ts.setProducer(ms.producer);
+        
+        ms.onNext(Observable.just(1));
+        
+        BackpressureUtils.getAndAddRequest(ms.producer, 2);
+        
+        ms.onNext(Observable.just(2));
+        
+        ms.emit();
+        
+        ts.assertValues(1, 2);
+    }
 }

From a45de22ca3a847584c1a7640c138a89ac52d6f58 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 20 Jul 2016 23:17:11 +0200
Subject: [PATCH 110/263] 1.x: fix assembly tracking replacing original
 exception (#4215)

* 1.x: fix assembly tracking replacing original exception

* Rename attach() to attachTo()
---
 src/main/java/rx/Observable.java              |  1 +
 src/main/java/rx/Scheduler.java               |  6 +-
 .../AssemblyStackTraceException.java          | 57 +++++++++++++++----
 .../operators/OnSubscribeOnAssembly.java      |  2 +-
 .../OnSubscribeOnAssemblyCompletable.java     |  2 +-
 .../OnSubscribeOnAssemblySingle.java          |  2 +-
 src/main/java/rx/plugins/RxJavaHooks.java     |  2 +-
 src/test/java/rx/plugins/RxJavaHooksTest.java | 54 ++++++++++++------
 8 files changed, 92 insertions(+), 34 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 7114a42e76..4cbf28d18e 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -1712,6 +1712,7 @@ public static <T> Observable<T> from(T[] array) {
      * You should call the AsyncEmitter's onNext, onError and onCompleted methods in a serialized fashion. The
      * rest of its methods are threadsafe.
      * 
+     * @param <T> the element type
      * @param asyncEmitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
      * @param backpressure the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
      * @return the new Observable instance
diff --git a/src/main/java/rx/Scheduler.java b/src/main/java/rx/Scheduler.java
index 756963e66f..1487373fcc 100644
--- a/src/main/java/rx/Scheduler.java
+++ b/src/main/java/rx/Scheduler.java
@@ -253,8 +253,10 @@ public long now() {
 	 * });
 	 * </pre>
 	 * 
-	 * @param combine
-	 * @return
+	 * @param <S> a Scheduler and a Subscription
+	 * @param combine the function that takes a two-level nested Observable sequence of a Completable and returns
+	 * the Completable that will be subscribed to and should trigger the execution of the scheduled Actions.
+	 * @return the Scheduler with the customized execution behavior
 	 */
     @SuppressWarnings("unchecked")
     @Experimental
diff --git a/src/main/java/rx/exceptions/AssemblyStackTraceException.java b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
index 752e8aad87..110fc803c8 100644
--- a/src/main/java/rx/exceptions/AssemblyStackTraceException.java
+++ b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
@@ -15,7 +15,10 @@
  */
 package rx.exceptions;
 
+import java.util.*;
+
 import rx.annotations.Experimental;
+import rx.plugins.RxJavaHooks;
 
 /**
  * A RuntimeException that is stackless but holds onto a textual
@@ -27,16 +30,6 @@ public final class AssemblyStackTraceException extends RuntimeException {
     /** */
     private static final long serialVersionUID = 2038859767182585852L;
 
-    /**
-     * Constructs an AssemblyStackTraceException with the given message and
-     * a cause.
-     * @param message the message
-     * @param cause the cause
-     */
-    public AssemblyStackTraceException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
     /**
      * Constructs an AssemblyStackTraceException with the given message.
      * @param message the message
@@ -49,4 +42,48 @@ public AssemblyStackTraceException(String message) {
     public synchronized Throwable fillInStackTrace() { // NOPMD 
         return this;
     }
+    
+    /**
+     * Finds an empty cause slot and assigns itself to it.
+     * @param exception the exception to start from
+     */
+    public void attachTo(Throwable exception) {
+        Set<Throwable> memory = new HashSet<Throwable>();
+        
+        for (;;) {
+            if (exception.getCause() == null) {
+                exception.initCause(this);
+                return;
+            }
+            
+            exception = exception.getCause();
+            if (!memory.add(exception)) {
+                // in case we run into a cycle, give up and report this to the hooks
+                RxJavaHooks.onError(this);
+                return;
+            }
+        }
+    }
+    
+    /**
+     * Locate the first AssemblyStackTraceException in the causal chain of the
+     * given Throwable (or it if it's one).
+     * @param e the input throwable 
+     * @return the AssemblyStackTraceException located or null if not found 
+     */
+    public static AssemblyStackTraceException find(Throwable e) {
+        Set<Throwable> memory = new HashSet<Throwable>();
+        for (;;) {
+            if (e instanceof AssemblyStackTraceException) {
+                return (AssemblyStackTraceException)e;
+            }
+            if (e == null || e.getCause() == null) {
+                return null;
+            }
+            e = e.getCause();
+            if (!memory.add(e)) {
+                return null;
+            }
+        }
+    }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
index 11c7bcff0e..f26dda29dc 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
@@ -115,7 +115,7 @@ public void onCompleted() {
 
         @Override
         public void onError(Throwable e) {
-            e = new AssemblyStackTraceException(stacktrace, e);
+            new AssemblyStackTraceException(stacktrace).attachTo(e);
             actual.onError(e);
         }
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
index da5a144045..c8d7eaf52f 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
@@ -71,7 +71,7 @@ public void onCompleted() {
 
         @Override
         public void onError(Throwable e) {
-            e = new AssemblyStackTraceException(stacktrace, e);
+            new AssemblyStackTraceException(stacktrace).attachTo(e);
             actual.onError(e);
         }
     }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java
index aeed623a7b..be5ce6cb5f 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java
@@ -61,7 +61,7 @@ public OnAssemblySingleSubscriber(SingleSubscriber<? super T> actual, String sta
 
         @Override
         public void onError(Throwable e) {
-            e = new AssemblyStackTraceException(stacktrace, e);
+            new AssemblyStackTraceException(stacktrace).attachTo(e);
             actual.onError(e);
         }
 
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index cef9a8f6fb..75602e7c2b 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -974,7 +974,7 @@ public static Func1<Operator, Operator> getOnSingleLift() {
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
-     * @param onObservableLift the function that is called with original Operator and should
+     * @param onCompletableLift the function that is called with original Operator and should
      * return an Operator instance.
      */
     public static void setOnCompletableLift(Func1<CompletableOperator, CompletableOperator> onCompletableLift) {
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index 9209228124..a1df503815 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -64,15 +64,15 @@ public void assemblyTrackingObservable() {
             
             createObservable().subscribe(ts);
             
-            ts.assertError(AssemblyStackTraceException.class);
+            ts.assertError(TestException.class);
             
             Throwable ex = ts.getOnErrorEvents().get(0);
             
-            assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
+            AssemblyStackTraceException aste = AssemblyStackTraceException.find(ex);
             
-            assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
+            assertNotNull(aste);
             
-            assertTrue(ex.getMessage(), ex.getMessage().contains("createObservable"));
+            assertTrue(aste.getMessage(), aste.getMessage().contains("createObservable"));
             
             RxJavaHooks.clearAssemblyTracking();
 
@@ -81,6 +81,12 @@ public void assemblyTrackingObservable() {
             createObservable().subscribe(ts);
 
             ts.assertError(TestException.class);
+            
+            ex = ts.getOnErrorEvents().get(0);
+            
+            aste = AssemblyStackTraceException.find(ex);
+
+            assertNull(aste);
         } finally {
             RxJavaHooks.resetAssemblyTracking();
         }
@@ -103,15 +109,15 @@ public void assemblyTrackingSingle() {
             
             createSingle().subscribe(ts);
             
-            ts.assertError(AssemblyStackTraceException.class);
+            ts.assertError(TestException.class);
             
             Throwable ex = ts.getOnErrorEvents().get(0);
-
-            assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
-
-            assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
-
-            assertTrue(ex.getMessage(), ex.getMessage().contains("createSingle"));
+            
+            AssemblyStackTraceException aste = AssemblyStackTraceException.find(ex);
+            
+            assertNotNull(aste);
+            
+            assertTrue(aste.getMessage(), aste.getMessage().contains("createSingle"));
 
             RxJavaHooks.clearAssemblyTracking();
 
@@ -120,6 +126,12 @@ public void assemblyTrackingSingle() {
             createSingle().subscribe(ts);
 
             ts.assertError(TestException.class);
+            
+            ex = ts.getOnErrorEvents().get(0);
+            
+            aste = AssemblyStackTraceException.find(ex);
+
+            assertNull(aste);
         } finally {
             RxJavaHooks.resetAssemblyTracking();
         }
@@ -142,15 +154,15 @@ public void assemblyTrackingCompletable() {
             
             createCompletable().subscribe(ts);
             
-            ts.assertError(AssemblyStackTraceException.class);
+            ts.assertError(TestException.class);
             
             Throwable ex = ts.getOnErrorEvents().get(0);
-
-            assertTrue("" + ex, ex instanceof AssemblyStackTraceException);
-
-            assertTrue("" + ex.getCause(), ex.getCause() instanceof TestException);
-
-            assertTrue(ex.getMessage(), ex.getMessage().contains("createCompletable"));
+            
+            AssemblyStackTraceException aste = AssemblyStackTraceException.find(ex);
+            
+            assertNotNull(aste);
+            
+            assertTrue(aste.getMessage(), aste.getMessage().contains("createCompletable"));
 
             RxJavaHooks.clearAssemblyTracking();
 
@@ -160,6 +172,12 @@ public void assemblyTrackingCompletable() {
 
             ts.assertError(TestException.class);
 
+            ex = ts.getOnErrorEvents().get(0);
+            
+            aste = AssemblyStackTraceException.find(ex);
+
+            assertNull(aste);
+            
         } finally {
             RxJavaHooks.resetAssemblyTracking();
         }

From 479df3195f208888fe8cfc91c9ce8367c5b4cc07 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 22 Jul 2016 09:42:37 +0200
Subject: [PATCH 111/263] 1.x: PublishSubject perf (#4224)

* 1.x: PublishSubject perf

* Update year.
---
 .../java/rx/subjects/PublishSubjectPerf.java  | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 src/perf/java/rx/subjects/PublishSubjectPerf.java

diff --git a/src/perf/java/rx/subjects/PublishSubjectPerf.java b/src/perf/java/rx/subjects/PublishSubjectPerf.java
new file mode 100644
index 0000000000..6c95d0f64e
--- /dev/null
+++ b/src/perf/java/rx/subjects/PublishSubjectPerf.java
@@ -0,0 +1,62 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.subjects;
+
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+
+import rx.jmh.LatchedObserver;
+
+/**
+ * Benchmark PublishSubject.
+ * <p>
+ * gradlew benchmarks "-Pjmh=-f 1 -tu s -bm thrpt -wi 5 -i 5 -r 1 .*PublishSubjectPerf.*"
+ * <p>
+ * gradlew benchmarks "-Pjmh=-f 1 -tu ns -bm avgt -wi 5 -i 5 -r 1 .*PublishSubjectPerf.*"
+ */
+@BenchmarkMode(Mode.Throughput)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@State(Scope.Thread)
+public class PublishSubjectPerf {
+    
+    @Param({ "1", "2", "4", "8"})
+    public int subscribers;
+    
+    @Param({ "1", "1000", "1000000"})
+    public int count;
+    
+    @Benchmark
+    public Object benchmark(Blackhole bh) {
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        int s = subscribers;
+        for (int i = 0; i < s; i++) {
+            ps.subscribe(new LatchedObserver<Integer>(bh));
+        }
+        
+        int c = count;
+        for (int i = 0; i < c; i++) {
+            ps.onNext(777);
+        }
+        
+        ps.onCompleted();
+        
+        return ps;
+    }
+}

From 75ffcbb01cae042f5b715060622154794f39a690 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 23 Jul 2016 09:14:43 +0200
Subject: [PATCH 112/263] 1.x: fix replay() retaining reference to the child
 Subscriber (#4229)

---
 .../rx/internal/operators/OperatorReplay.java | 26 ++++--
 .../operators/OperatorReplayTest.java         | 82 +++++++++++++++++++
 2 files changed, 103 insertions(+), 5 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorReplay.java b/src/main/java/rx/internal/operators/OperatorReplay.java
index 86774cbd39..33e14b15de 100644
--- a/src/main/java/rx/internal/operators/OperatorReplay.java
+++ b/src/main/java/rx/internal/operators/OperatorReplay.java
@@ -410,6 +410,7 @@ boolean add(InnerProducer<T> producer) {
          * Atomically removes the given producer from the producers array.
          * @param producer the producer to remove
          */
+        @SuppressWarnings("unchecked")
         void remove(InnerProducer<T> producer) {
             if (terminated) {
                 return;
@@ -419,6 +420,9 @@ void remove(InnerProducer<T> producer) {
                     return;
                 }
                 producers.remove(producer);
+                if (producers.isEmpty()) {
+                    producersCache = EMPTY;
+                }
                 producersVersion++;
             }
         }
@@ -643,7 +647,7 @@ static final class InnerProducer<T> extends AtomicLong implements Producer, Subs
          */
         final ReplaySubscriber<T> parent;
         /** The actual child subscriber. */
-        final Subscriber<? super T> child;
+        Subscriber<? super T> child;
         /** 
          * Holds an object that represents the current location in the buffer.
          * Guarded by the emitter loop. 
@@ -784,6 +788,8 @@ public void unsubscribe() {
                     // the others had non-zero. By removing this 'blocking' child, the others
                     // are now free to receive events
                     parent.manageRequests(this);
+                    // break the reference
+                    child = null;
                 }
             }
         }
@@ -878,20 +884,25 @@ public void replay(InnerProducer<T> output) {
                 Integer destIndexObject = output.index();
                 int destIndex = destIndexObject != null ? destIndexObject : 0;
                 
+                Subscriber<? super T> child = output.child;
+                if (child == null) {
+                    return;
+                }
+
                 long r = output.get();
                 long e = 0L;
                 
                 while (e != r && destIndex < sourceIndex) {
                     Object o = get(destIndex);
                     try {
-                        if (nl.accept(output.child, o)) {
+                        if (nl.accept(child, o)) {
                             return;
                         }
                     } catch (Throwable err) {
                         Exceptions.throwIfFatal(err);
                         output.unsubscribe();
                         if (!nl.isError(o) && !nl.isCompleted(o)) {
-                            output.child.onError(OnErrorThrowable.addValueAsLastCause(err, nl.getValue(o)));
+                            child.onError(OnErrorThrowable.addValueAsLastCause(err, nl.getValue(o)));
                         }
                         return;
                     }
@@ -1066,6 +1077,11 @@ public final void replay(InnerProducer<T> output) {
                     return;
                 }
 
+                Subscriber<? super T> child = output.child;
+                if (child == null) {
+                    return;
+                }
+
                 long r = output.get();
                 long e = 0L;
 
@@ -1074,7 +1090,7 @@ public final void replay(InnerProducer<T> output) {
                     if (v != null) {
                         Object o = leaveTransform(v.value);
                         try {
-                            if (nl.accept(output.child, o)) {
+                            if (nl.accept(child, o)) {
                                 output.index = null;
                                 return;
                             }
@@ -1083,7 +1099,7 @@ public final void replay(InnerProducer<T> output) {
                             Exceptions.throwIfFatal(err);
                             output.unsubscribe();
                             if (!nl.isError(o) && !nl.isCompleted(o)) {
-                                output.child.onError(OnErrorThrowable.addValueAsLastCause(err, nl.getValue(o)));
+                                child.onError(OnErrorThrowable.addValueAsLastCause(err, nl.getValue(o)));
                             }
                             return;
                         }
diff --git a/src/test/java/rx/internal/operators/OperatorReplayTest.java b/src/test/java/rx/internal/operators/OperatorReplayTest.java
index fafe4ebc58..d3415d6e6e 100644
--- a/src/test/java/rx/internal/operators/OperatorReplayTest.java
+++ b/src/test/java/rx/internal/operators/OperatorReplayTest.java
@@ -19,6 +19,7 @@
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
+import java.lang.management.*;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
@@ -1495,4 +1496,85 @@ public void timeSizeDefaultScheduler() {
         ts.assertNoErrors();
         ts.assertCompleted();
     }
+    
+    void replayNoRetention(Func1<Observable<Integer>, ConnectableObservable<Integer>> replayOp) throws InterruptedException {
+        System.gc();
+        
+        Thread.sleep(500);
+        
+        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
+        MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
+        long initial = memHeap.getUsed();
+
+        System.out.printf("Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
+        
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        ConnectableObservable<Integer> co = replayOp.call(ps);
+        
+        Subscription s = co.subscribe(new Action1<Integer>() {
+            int[] array = new int[1024 * 1024 * 32];
+            
+            @Override
+            public void call(Integer t) {
+                System.out.println(array.length);
+            }
+        });
+
+        co.connect();
+        ps.onNext(1); 
+        
+        memHeap = memoryMXBean.getHeapMemoryUsage();
+        long middle = memHeap.getUsed();
+
+        System.out.printf("Starting: %.3f MB%n", middle / 1024.0 / 1024.0);
+
+        s.unsubscribe();
+        s = null;
+        
+        System.gc();
+        
+        Thread.sleep(500);
+
+        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("Leak: %.3f -> %.3f -> %.3f", initial / 1024 / 1024.0, middle / 1024 / 1024.0, finish / 1024 / 1024d));
+        }
+        
+    }
+    
+    @Test
+    public void replayNoRetentionUnbounded() throws Exception {
+        replayNoRetention(new Func1<Observable<Integer>, ConnectableObservable<Integer>>() {
+            @Override
+            public ConnectableObservable<Integer> call(Observable<Integer> o) {
+                return o.replay();
+            }
+        });
+    }
+
+    @Test
+    public void replayNoRetentionSizeBound() throws Exception {
+        replayNoRetention(new Func1<Observable<Integer>, ConnectableObservable<Integer>>() {
+            @Override
+            public ConnectableObservable<Integer> call(Observable<Integer> o) {
+                return o.replay(1);
+            }
+        });
+    }
+    
+    @Test
+    public void replayNoRetentionTimebound() throws Exception {
+        replayNoRetention(new Func1<Observable<Integer>, ConnectableObservable<Integer>>() {
+            @Override
+            public ConnectableObservable<Integer> call(Observable<Integer> o) {
+                return o.replay(1, TimeUnit.DAYS);
+            }
+        });
+    }
+
 }
\ No newline at end of file

From 2284d4ffad2c063e9478b7b685b350fc2c0d49a3 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Sat, 23 Jul 2016 09:21:27 +0200
Subject: [PATCH 113/263] Update changes.md

---
 CHANGES.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 3c5370b059..1e911b3b10 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,13 @@
 # RxJava Releases #
 
+### Version 1.1.8 - July 23, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.8%7C))
+
+#### Bugfixes
+
+  - [Pull 4209](https://github.com/ReactiveX/RxJava/pull/4209): `merge`/`flatMap` to keep scalar/inner element relative order.
+  - [Pull 4215](https://github.com/ReactiveX/RxJava/pull/4215): Fix assembly tracking replacing original exception.
+  - [Pull 4229](https://github.com/ReactiveX/RxJava/pull/4229): fix replay() retaining reference to the child Subscriber
+
 ### Version 1.1.7 - July 10, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.7%7C))
 
 This release has several documentation fixes (`AsyncSubject`, `doOnEach`, `cache`, `scan`, `reduce`, backpressure descriptions) and internal cleanups based on tool feedback (code-coverage and PMD).

From cbec342278eddc94d58a590ee45e272d07018049 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Sat, 23 Jul 2016 22:14:13 +1000
Subject: [PATCH 114/263] save allocation in OnSubscribeAmb (#4232)

---
 .../rx/internal/operators/OnSubscribeAmb.java | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OnSubscribeAmb.java b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
index 7469e7c417..e72a29f8ee 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeAmb.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
@@ -320,12 +320,12 @@ private boolean isSelected() {
             if (chosen) {
                 return true;
             }
-            if (selection.choice.get() == this) {
+            if (selection.get() == this) {
                 // fast-path
                 chosen = true;
                 return true;
             } else {
-                if (selection.choice.compareAndSet(null, this)) {
+                if (selection.compareAndSet(null, this)) {
                     selection.unsubscribeOthers(this);
                     chosen = true;
                     return true;
@@ -338,12 +338,12 @@ private boolean isSelected() {
         }
     }
 
-    static final class Selection<T> {
-        final AtomicReference<AmbSubscriber<T>> choice = new AtomicReference<AmbSubscriber<T>>();
+    @SuppressWarnings("serial")
+	static final class Selection<T> extends AtomicReference<AmbSubscriber<T>> {
         final Collection<AmbSubscriber<T>> ambSubscribers = new ConcurrentLinkedQueue<AmbSubscriber<T>>();
 
         public void unsubscribeLosers() {
-            AmbSubscriber<T> winner = choice.get();
+            AmbSubscriber<T> winner = get();
             if(winner != null) {
                 unsubscribeOthers(winner);
             }
@@ -367,7 +367,6 @@ private OnSubscribeAmb(Iterable<? extends Observable<? extends T>> sources) {
     @Override
     public void call(final Subscriber<? super T> subscriber) {
         final Selection<T> selection = new Selection<T>();
-        final AtomicReference<AmbSubscriber<T>> choice = selection.choice;
         
         //setup unsubscription of all the subscribers to the sources
         subscriber.add(Subscriptions.create(new Action0() {
@@ -375,7 +374,7 @@ public void call(final Subscriber<? super T> subscriber) {
             @Override
             public void call() {
                 AmbSubscriber<T> c;
-                if ((c = choice.get()) != null) {
+                if ((c = selection.get()) != null) {
                     // there is a single winner so we unsubscribe it
                     c.unsubscribe();
                 } 
@@ -399,7 +398,7 @@ public void call() {
             // if all sources were backpressure aware then this check 
             // would be pointless given that 0 was requested above from each ambSubscriber
             AmbSubscriber<T> c;
-            if ((c = choice.get()) != null) {
+            if ((c = selection.get()) != null) {
                 // Already chose one, the rest can be skipped and we can clean up
                 selection.unsubscribeOthers(c);
                 return;
@@ -416,7 +415,7 @@ public void call() {
             @Override
             public void request(long n) {
                 AmbSubscriber<T> c;
-                if ((c = choice.get()) != null) {
+                if ((c = selection.get()) != null) {
                     // propagate the request to that single Subscriber that won
                     c.requestMore(n);
                 } else {
@@ -425,7 +424,7 @@ public void request(long n) {
                         if (!ambSubscriber.isUnsubscribed()) {
                             // make a best endeavours check to not waste requests 
                             // if first emission has already occurred
-                            if (choice.get() == ambSubscriber) {
+                            if (selection.get() == ambSubscriber) {
                                 ambSubscriber.requestMore(n);
                                 // don't need to request from other subscribers because choice has been made
                                 // and request has gone to choice 

From 99abbf982fdadf9ff1cff9fa7ff79e8e72a212bd Mon Sep 17 00:00:00 2001
From: Csaba Kos <csabakos@users.noreply.github.com>
Date: Sat, 23 Jul 2016 21:24:03 +0900
Subject: [PATCH 115/263] =?UTF-8?q?CachedThreadScheduler=20should=20wait?=
 =?UTF-8?q?=20until=20the=20previous=20action=20(if=20any)=20=E2=80=A6=20(?=
 =?UTF-8?q?#4231)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* CachedThreadScheduler should wait until the previous action (if any) completes before releasing a worker to the pool. Fixes #4230.

* Modified EventLoopWorker to implement Action0 and schedule itself to release. This saves an allocation.
---
 .../schedulers/CachedThreadScheduler.java     | 11 ++-
 .../java/rx/schedulers/IoSchedulerTest.java   | 69 +++++++++++++++++++
 2 files changed, 78 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
index 2443400c48..99e595fbf0 100644
--- a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
+++ b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
@@ -174,7 +174,7 @@ public Worker createWorker() {
         return new EventLoopWorker(pool.get());
     }
 
-    static final class EventLoopWorker extends Scheduler.Worker {
+    static final class EventLoopWorker extends Scheduler.Worker implements Action0 {
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
         private final CachedWorkerPool pool;
         private final ThreadWorker threadWorker;
@@ -190,11 +190,18 @@ static final class EventLoopWorker extends Scheduler.Worker {
         public void unsubscribe() {
             if (once.compareAndSet(false, true)) {
                 // unsubscribe should be idempotent, so only do this once
-                pool.release(threadWorker);
+
+                // Release the worker _after_ the previous action (if any) has completed
+                threadWorker.schedule(this);
             }
             innerSubscription.unsubscribe();
         }
 
+        @Override
+        public void call() {
+            pool.release(threadWorker);
+        }
+
         @Override
         public boolean isUnsubscribed() {
             return innerSubscription.isUnsubscribed();
diff --git a/src/test/java/rx/schedulers/IoSchedulerTest.java b/src/test/java/rx/schedulers/IoSchedulerTest.java
index 775f6fd507..2db6d5c7b6 100644
--- a/src/test/java/rx/schedulers/IoSchedulerTest.java
+++ b/src/test/java/rx/schedulers/IoSchedulerTest.java
@@ -18,6 +18,8 @@
 
 import static org.junit.Assert.assertTrue;
 
+import java.util.concurrent.atomic.AtomicBoolean;
+
 import org.junit.Test;
 
 import rx.*;
@@ -83,4 +85,71 @@ public void testCancelledTaskRetention() throws InterruptedException {
         }
     }
 
+    // Tests that an uninterruptible worker does not get reused
+    @Test(timeout = 10000)
+    public void testUninterruptibleActionDoesNotBlockOtherAction() throws InterruptedException {
+        final Worker uninterruptibleWorker = Schedulers.io().createWorker();
+        final AtomicBoolean running = new AtomicBoolean(false);
+        final AtomicBoolean shouldQuit = new AtomicBoolean(false);
+        try {
+            uninterruptibleWorker.schedule(new Action0() {
+                @Override
+                public void call() {
+                    synchronized (running) {
+                        running.set(true);
+                        running.notifyAll();
+                    }
+                    synchronized (shouldQuit) {
+                        while (!shouldQuit.get()) {
+                            try {
+                                shouldQuit.wait();
+                            } catch (final InterruptedException ignored) {
+                            }
+                        }
+                    }
+                    synchronized (running) {
+                        running.set(false);
+                        running.notifyAll();
+                    }
+                }
+            });
+
+            // Wait for the action to start executing
+            synchronized (running) {
+                while (!running.get()) {
+                    running.wait();
+                }
+            }
+        } finally {
+            uninterruptibleWorker.unsubscribe();
+        }
+
+        final Worker otherWorker = Schedulers.io().createWorker();
+        final AtomicBoolean otherActionRan = new AtomicBoolean(false);
+        try {
+            otherWorker.schedule(new Action0() {
+                @Override
+                public void call() {
+                    otherActionRan.set(true);
+                }
+            });
+            Thread.sleep(1000); // give the action a chance to run
+        } finally {
+            otherWorker.unsubscribe();
+        }
+
+        assertTrue(running.get()); // uninterruptible action keeps on running since InterruptedException is swallowed
+        assertTrue(otherActionRan.get());
+
+        // Wait for uninterruptibleWorker to exit (to clean up after ourselves)
+        synchronized (shouldQuit) {
+            shouldQuit.set(true);
+            shouldQuit.notifyAll();
+        }
+        synchronized (running) {
+            while (running.get()) {
+                running.wait();
+            }
+        }
+    }
 }

From 791379d855ae0b9c9b2067ce5167f900d126bc32 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Sat, 23 Jul 2016 22:41:04 +1000
Subject: [PATCH 116/263] save allocation in OnSubscribeAutoConnect (#4233)

---
 .../internal/operators/OnSubscribeAutoConnect.java   | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java b/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
index 135888d310..be1a5bc6c6 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
@@ -29,11 +29,13 @@
  *
  * @param <T> the value type of the chain
  */
-public final class OnSubscribeAutoConnect<T> implements OnSubscribe<T> {
-    final ConnectableObservable<? extends T> source;
+@SuppressWarnings("serial")
+public final class OnSubscribeAutoConnect<T> extends AtomicInteger implements OnSubscribe<T> {
+    // AtomicInteger aspect of `this` represents the number of clients
+	
+	final ConnectableObservable<? extends T> source;
     final int numberOfSubscribers;
     final Action1<? super Subscription> connection;
-    final AtomicInteger clients;
     
     public OnSubscribeAutoConnect(ConnectableObservable<? extends T> source,
             int numberOfSubscribers,
@@ -44,12 +46,12 @@ public OnSubscribeAutoConnect(ConnectableObservable<? extends T> source,
         this.source = source;
         this.numberOfSubscribers = numberOfSubscribers;
         this.connection = connection;
-        this.clients = new AtomicInteger();
     }
     @Override
     public void call(Subscriber<? super T> child) {
         source.unsafeSubscribe(Subscribers.wrap(child));
-        if (clients.incrementAndGet() == numberOfSubscribers) {
+        //this.get() represents the number of clients
+        if (this.incrementAndGet() == numberOfSubscribers) {
             source.connect(connection);
         }
     }

From 7d42628e3be0dd9b885f13fdfbc61627945b86b1 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Sat, 23 Jul 2016 15:11:37 +0200
Subject: [PATCH 117/263] 1.x: Fix some typos (#4234)

---
 src/main/java/rx/Completable.java             |  2 +-
 src/main/java/rx/Single.java                  | 20 +++++++++----------
 .../OnSubscribeToObservableFuture.java        |  2 +-
 src/main/java/rx/plugins/RxJavaHooks.java     |  2 +-
 src/test/java/rx/ZipTests.java                |  2 +-
 .../operators/BlockingOperatorNextTest.java   |  6 +++---
 6 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 2f6f3cce50..6848ea05bb 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -1660,7 +1660,7 @@ public final Completable onErrorComplete() {
     /**
      * Returns a Completable instance that if this Completable emits an error and the predicate returns
      * true, it will emit an onComplete and swallow the throwable.
-     * @param predicate the predicate to call when an Throwable is emitted which should return true
+     * @param predicate the predicate to call when a Throwable is emitted which should return true
      * if the Throwable should be swallowed and replaced with an onComplete.
      * @return the new Completable instance
      */
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 3fa4cc39ac..c869225b3e 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -266,9 +266,9 @@ private Single<Observable<T>> nest() {
      * 
      * @param <T> the common value type
      * @param t1
-     *            an Single to be concatenated
+     *            a Single to be concatenated
      * @param t2
-     *            an Single to be concatenated
+     *            a Single to be concatenated
      * @return an Observable that emits items emitted by the two source Singles, one after the other.
      * @see <a href="http://reactivex.io/documentation/operators/concat.html">ReactiveX operators documentation: Concat</a>
      */
@@ -1504,7 +1504,7 @@ public final Single<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunctio
      * By default, when a Single encounters an error that prevents it from emitting the expected item to
      * its {@link Observer}, the Single invokes its Observer's {@code onError} method, and then quits
      * without invoking any more of its Observer's methods. The {@code onErrorResumeNext} method changes this
-     * behavior. If you pass another Single ({@code resumeSingleInCaseOfError}) to an Single's
+     * behavior. If you pass another Single ({@code resumeSingleInCaseOfError}) to a Single's
      * {@code onErrorResumeNext} method, if the original Single encounters an error, instead of invoking its
      * Observer's {@code onError} method, it will instead relinquish control to {@code resumeSingleInCaseOfError} which
      * will invoke the Observer's {@link Observer#onNext onNext} method if it is able to do so. In such a case,
@@ -1538,7 +1538,7 @@ public final Single<T> onErrorResumeNext(Single<? extends T> resumeSingleInCaseO
      * By default, when a Single encounters an error that prevents it from emitting the expected item to
      * its {@link Observer}, the Single invokes its Observer's {@code onError} method, and then quits
      * without invoking any more of its Observer's methods. The {@code onErrorResumeNext} method changes this
-     * behavior. If you pass a function that will return another Single ({@code resumeFunctionInCaseOfError}) to an Single's
+     * behavior. If you pass a function that will return another Single ({@code resumeFunctionInCaseOfError}) to a Single's
      * {@code onErrorResumeNext} method, if the original Single encounters an error, instead of invoking its
      * Observer's {@code onError} method, it will instead relinquish control to {@code resumeSingleInCaseOfError} which
      * will invoke the Observer's {@link Observer#onNext onNext} method if it is able to do so. In such a case,
@@ -2452,7 +2452,7 @@ public final Single<T> doOnSubscribe(final Action0 subscribe) {
     }
 
     /**
-     * Returns an Single that emits the items emitted by the source Single shifted forward in time by a
+     * Returns a Single that emits the items emitted by the source Single shifted forward in time by a
      * specified delay. Error notifications from the source Single are not delayed.
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/delay.s.png" alt="">
@@ -2476,7 +2476,7 @@ public final Single<T> delay(long delay, TimeUnit unit, Scheduler scheduler) {
     }
 
     /**
-     * Returns an Single that emits the items emitted by the source Single shifted forward in time by a
+     * Returns a Single that emits the items emitted by the source Single shifted forward in time by a
      * specified delay. Error notifications from the source Observable are not delayed.
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/delay.png" alt="">
@@ -2646,7 +2646,7 @@ public final Single<T> retry() {
     }
 
     /**
-     * Returns an Single that mirrors the source Single, resubscribing to it if it calls {@code onError}
+     * Returns a Single that mirrors the source Single, resubscribing to it if it calls {@code onError}
      * up to a specified number of retries.
      *
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/retry.png" alt="">
@@ -2671,7 +2671,7 @@ public final Single<T> retry(final long count) {
     }
 
     /**
-     * Returns an Single that mirrors the source Single, resubscribing to it if it calls {@code onError}
+     * Returns a Single that mirrors the source Single, resubscribing to it if it calls {@code onError}
      * and the predicate returns true for that specific exception and retry count.
      *
      * <img width="640" height="315" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/retry.png" alt="">
@@ -2739,7 +2739,7 @@ public final Single<T> retryWhen(final Func1<Observable<? extends Throwable>, ?
     }
 
     /**
-     * Constructs an Single that creates a dependent resource object which is disposed of on unsubscription.
+     * Constructs a Single that creates a dependent resource object which is disposed of on unsubscription.
      * <p>
      * <img width="640" height="400" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/using.png" alt="">
      * <dl>
@@ -2767,7 +2767,7 @@ public static <T, Resource> Single<T> using(
     }
     
     /**
-     * Constructs an Single that creates a dependent resource object which is disposed of just before 
+     * Constructs a Single that creates a dependent resource object which is disposed of just before 
      * termination if you have set {@code disposeEagerly} to {@code true} and unsubscription does not occur
      * before termination. Otherwise resource disposal will occur on unsubscription.  Eager disposal is
      * particularly appropriate for a synchronous Single that reuses resources. {@code disposeAction} will
diff --git a/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java b/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
index 2c36da8611..8e469c296e 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
@@ -74,7 +74,7 @@ public void call() {
                 T value = (unit == null) ? (T) that.get() : (T) that.get(time, unit);
                 subscriber.setProducer(new SingleProducer<T>(subscriber, value));
             } catch (Throwable e) {
-                // If this Observable is unsubscribed, we will receive an CancellationException.
+                // If this Observable is unsubscribed, we will receive a CancellationException.
                 // However, CancellationException will not be passed to the final Subscriber
                 // since it's already subscribed.
                 // If the Future is canceled in other place, CancellationException will be still
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index 75602e7c2b..f32f3d6d0d 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -967,7 +967,7 @@ public static Func1<Operator, Operator> getOnSingleLift() {
     }
 
     /**
-     * Sets a hook function that is called with an operator when an Completable operator built with
+     * Sets a hook function that is called with an operator when a Completable operator built with
      * lift() gets subscribed to.
      * <p>
      * This operation is threadsafe.
diff --git a/src/test/java/rx/ZipTests.java b/src/test/java/rx/ZipTests.java
index 5d35ea94bf..782fbf84d1 100644
--- a/src/test/java/rx/ZipTests.java
+++ b/src/test/java/rx/ZipTests.java
@@ -102,7 +102,7 @@ public void testCovarianceOfZip() {
      * Occasionally zip may be invoked with 0 observables. Test that we don't block indefinitely instead
      * of immediately invoking zip with 0 argument.
      * 
-     * We now expect an NoSuchElementException since last() requires at least one value and nothing will be emitted.
+     * We now expect a NoSuchElementException since last() requires at least one value and nothing will be emitted.
      */
     @Test(expected = NoSuchElementException.class)
     public void nonBlockingObservable() {
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
index 338c5f5703..56fb66965b 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
@@ -113,7 +113,7 @@ public void testNextWithError() {
         fireOnErrorInNewThread(obs);
         try {
             it.hasNext();
-            fail("Expected an TestException");
+            fail("Expected a TestException");
         } catch (TestException e) {
         }
 
@@ -149,7 +149,7 @@ public void testOnError() throws Throwable {
         obs.onError(new TestException());
         try {
             it.hasNext();
-            fail("Expected an TestException");
+            fail("Expected a TestException");
         } catch (TestException e) {
             // successful
         }
@@ -166,7 +166,7 @@ public void testOnErrorInNewThread() {
 
         try {
             it.hasNext();
-            fail("Expected an TestException");
+            fail("Expected a TestException");
         } catch (TestException e) {
             // successful
         }

From 89f2d6f3f1f339bb4b1cf571f6d4c5e7460cfdda Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Sun, 24 Jul 2016 16:39:37 +1000
Subject: [PATCH 118/263] reduce allocations in OnSubscribeJoin (#4236)

---
 .../internal/operators/OnSubscribeJoin.java   | 50 +++++++++++--------
 1 file changed, 28 insertions(+), 22 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OnSubscribeJoin.java b/src/main/java/rx/internal/operators/OnSubscribeJoin.java
index f93437c5d0..d5d7f08f3b 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeJoin.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeJoin.java
@@ -61,30 +61,36 @@ public void call(Subscriber<? super R> t1) {
     }
 
     /** Manage the left and right sources. */
-    final class ResultSink {
+    final class ResultSink extends HashMap<Integer,TLeft> {
+        //HashMap aspect of `this` refers to the `leftMap`
+        
+        private static final long serialVersionUID = 3491669543549085380L;
+
         final CompositeSubscription group;
         final Subscriber<? super R> subscriber;
-        final Object guard = new Object();
-        /** Guarded by guard. */
+        /** Guarded by this. */
         boolean leftDone;
-        /** Guarded by guard. */
+        /** Guarded by this. */
         int leftId;
-        /** Guarded by guard. */
-        final Map<Integer, TLeft> leftMap;
-        /** Guarded by guard. */
+        /** Guarded by this. */
         boolean rightDone;
-        /** Guarded by guard. */
+        /** Guarded by this. */
         int rightId;
-        /** Guarded by guard. */
+        /** Guarded by this. */
         final Map<Integer, TRight> rightMap;
 
         public ResultSink(Subscriber<? super R> subscriber) {
+            super();
             this.subscriber = subscriber;
             this.group = new CompositeSubscription();
-            this.leftMap = new HashMap<Integer, TLeft>();
+            //`leftMap` is `this`
             this.rightMap = new HashMap<Integer, TRight>();
         }
 
+        HashMap<Integer, TLeft> leftMap() {
+            return this;
+        }
+        
         public void run() {
             subscriber.add(group);
             
@@ -103,8 +109,8 @@ final class LeftSubscriber extends Subscriber<TLeft> {
 
             protected void expire(int id, Subscription resource) {
                 boolean complete = false;
-                synchronized (guard) {
-                    if (leftMap.remove(id) != null && leftMap.isEmpty() && leftDone) {
+                synchronized (ResultSink.this) {
+                    if (leftMap().remove(id) != null && leftMap().isEmpty() && leftDone) {
                         complete = true;
                     }
                 }
@@ -121,9 +127,9 @@ public void onNext(TLeft args) {
                 int id;
                 int highRightId;
 
-                synchronized (guard) {
+                synchronized (ResultSink.this) {
                     id = leftId++;
-                    leftMap.put(id, args);
+                    leftMap().put(id, args);
                     highRightId = rightId;
                 }
 
@@ -137,7 +143,7 @@ public void onNext(TLeft args) {
                     duration.unsafeSubscribe(d1);
 
                     List<TRight> rightValues = new ArrayList<TRight>();
-                    synchronized (guard) {
+                    synchronized (ResultSink.this) {
                         for (Map.Entry<Integer, TRight> entry : rightMap.entrySet()) {
                             if (entry.getKey() < highRightId) {
                                 rightValues.add(entry.getValue());
@@ -162,9 +168,9 @@ public void onError(Throwable e) {
             @Override
             public void onCompleted() {
                 boolean complete = false;
-                synchronized (guard) {
+                synchronized (ResultSink.this) {
                     leftDone = true;
-                    if (rightDone || leftMap.isEmpty()) {
+                    if (rightDone || leftMap().isEmpty()) {
                         complete = true;
                     }
                 }
@@ -211,7 +217,7 @@ final class RightSubscriber extends Subscriber<TRight> {
 
             void expire(int id, Subscription resource) {
                 boolean complete = false;
-                synchronized (guard) {
+                synchronized (ResultSink.this) {
                     if (rightMap.remove(id) != null && rightMap.isEmpty() && rightDone) {
                         complete = true;
                     }
@@ -228,7 +234,7 @@ void expire(int id, Subscription resource) {
             public void onNext(TRight args) {
                 int id; 
                 int highLeftId;
-                synchronized (guard) {
+                synchronized (ResultSink.this) {
                     id = rightId++;
                     rightMap.put(id, args);
                     highLeftId = leftId;
@@ -247,8 +253,8 @@ public void onNext(TRight args) {
                     
 
                     List<TLeft> leftValues = new ArrayList<TLeft>();
-                    synchronized (guard) {
-                        for (Map.Entry<Integer, TLeft> entry : leftMap.entrySet()) {
+                    synchronized (ResultSink.this) {
+                        for (Map.Entry<Integer, TLeft> entry : leftMap().entrySet()) {
                             if (entry.getKey() < highLeftId) {
                                 leftValues.add(entry.getValue());
                             }
@@ -274,7 +280,7 @@ public void onError(Throwable e) {
             @Override
             public void onCompleted() {
                 boolean complete = false;
-                synchronized (guard) {
+                synchronized (ResultSink.this) {
                     rightDone = true;
                     if (leftDone || rightMap.isEmpty()) {
                         complete = true;

From c3a3d1ad38311226382411c6f470984dffb63947 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Sun, 24 Jul 2016 16:41:01 +1000
Subject: [PATCH 119/263] reduce allocations in OnSubscribeGroupJoin (#4237)

---
 .../operators/OnSubscribeGroupJoin.java       | 65 ++++++++++---------
 1 file changed, 36 insertions(+), 29 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java b/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
index e677fb9bc3..ddab514cc9 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
@@ -65,25 +65,27 @@ public void call(Subscriber<? super R> child) {
     }
 
     /** Manages sub-observers and subscriptions. */
-    final class ResultManager implements Subscription {
+    final class ResultManager extends HashMap<Integer, Observer<T2>>implements Subscription {
+        // HashMap aspect of `this` refers to `leftMap`
+        
+        private static final long serialVersionUID = -3035156013812425335L;
+        
         final RefCountSubscription cancel;
         final Subscriber<? super R> subscriber;
         final CompositeSubscription group;
-        final Object guard = new Object();
-        /** Guarded by guard. */
+        /** Guarded by this. */
         int leftIds;
-        /** Guarded by guard. */
+        /** Guarded by this. */
         int rightIds;
-        /** Guarded by guard. */
-        final Map<Integer, Observer<T2>> leftMap = new HashMap<Integer, Observer<T2>>(); // NOPMD 
-        /** Guarded by guard. */
+        /** Guarded by this. */
         final Map<Integer, T2> rightMap = new HashMap<Integer, T2>(); // NOPMD 
-        /** Guarded by guard. */
+        /** Guarded by this. */
         boolean leftDone;
-        /** Guarded by guard. */
+        /** Guarded by this. */
         boolean rightDone;
 
         public ResultManager(Subscriber<? super R> subscriber) {
+            super();
             this.subscriber = subscriber;
             this.group = new CompositeSubscription();
             this.cancel = new RefCountSubscription(group);
@@ -110,15 +112,20 @@ public void unsubscribe() {
         public boolean isUnsubscribed() {
             return cancel.isUnsubscribed();
         }
+        
+        Map<Integer, Observer<T2>> leftMap() {
+            return this;
+        }
+        
         /**
          * Notify everyone and cleanup.
          * @param e the exception
          */
         void errorAll(Throwable e) {
             List<Observer<T2>> list;
-            synchronized (guard) {
-                list = new ArrayList<Observer<T2>>(leftMap.values());
-                leftMap.clear();
+            synchronized (ResultManager.this) {
+                list = new ArrayList<Observer<T2>>(leftMap().values());
+                leftMap().clear();
                 rightMap.clear();
             }
             for (Observer<T2> o : list) {
@@ -132,8 +139,8 @@ void errorAll(Throwable e) {
          * @param e  the exception
          */
         void errorMain(Throwable e) {
-            synchronized (guard) {
-                leftMap.clear();
+            synchronized (ResultManager.this) {
+                leftMap().clear();
                 rightMap.clear();
             }            
             subscriber.onError(e);
@@ -158,9 +165,9 @@ public void onNext(T1 args) {
                     Subject<T2, T2> subj = PublishSubject.create();
                     Observer<T2> subjSerial = new SerializedObserver<T2>(subj);
                     
-                    synchronized (guard) {
+                    synchronized (ResultManager.this) {
                         id = leftIds++;
-                        leftMap.put(id, subjSerial);
+                        leftMap().put(id, subjSerial);
                     }
 
                     Observable<T2> window = Observable.create(new WindowObservableFunc<T2>(subj, cancel));
@@ -174,7 +181,7 @@ public void onNext(T1 args) {
                     R result = resultSelector.call(args, window);
 
                     List<T2> rightMapValues;
-                    synchronized (guard) {
+                    synchronized (ResultManager.this) {
                         rightMapValues = new ArrayList<T2>(rightMap.values());
                     }
                     
@@ -192,11 +199,11 @@ public void onNext(T1 args) {
             @Override
             public void onCompleted() {
                 List<Observer<T2>> list = null;
-                synchronized (guard) {
+                synchronized (ResultManager.this) {
                     leftDone = true;
                     if (rightDone) {
-                        list = new ArrayList<Observer<T2>>(leftMap.values());
-                        leftMap.clear();
+                        list = new ArrayList<Observer<T2>>(leftMap().values());
+                        leftMap().clear();
                         rightMap.clear();
                     }
                 }
@@ -216,7 +223,7 @@ final class RightObserver extends Subscriber<T2> {
             public void onNext(T2 args) {
                 try {
                     int id;
-                    synchronized (guard) {
+                    synchronized (ResultManager.this) {
                         id = rightIds++;
                         rightMap.put(id, args);
                     }
@@ -228,8 +235,8 @@ public void onNext(T2 args) {
                     duration.unsafeSubscribe(d2);
 
                     List<Observer<T2>> list;
-                    synchronized (guard) {
-                        list = new ArrayList<Observer<T2>>(leftMap.values());
+                    synchronized (ResultManager.this) {
+                        list = new ArrayList<Observer<T2>>(leftMap().values());
                     }
                     for (Observer<T2> o : list) {
                         o.onNext(args);
@@ -242,11 +249,11 @@ public void onNext(T2 args) {
             @Override
             public void onCompleted() {
                 List<Observer<T2>> list = null;
-                synchronized (guard) {
+                synchronized (ResultManager.this) {
                     rightDone = true;
                     if (leftDone) {
-                        list = new ArrayList<Observer<T2>>(leftMap.values());
-                        leftMap.clear();
+                        list = new ArrayList<Observer<T2>>(leftMap().values());
+                        leftMap().clear();
                         rightMap.clear();
                     }
                 }
@@ -273,8 +280,8 @@ public void onCompleted() {
                 if (once) {
                     once = false;
                     Observer<T2> gr;
-                    synchronized (guard) {
-                        gr = leftMap.remove(id);
+                    synchronized (ResultManager.this) {
+                        gr = leftMap().remove(id);
                     }
                     if (gr != null) {
                         gr.onCompleted();
@@ -306,7 +313,7 @@ public RightDurationObserver(int id) {
             public void onCompleted() {
                 if (once) {
                     once = false;
-                    synchronized (guard) {
+                    synchronized (ResultManager.this) {
                         rightMap.remove(id);
                     }
                     group.remove(this);

From 45f607279bdd5cd67d6e342156c8408e1ef63b7f Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Sun, 24 Jul 2016 14:08:51 +0200
Subject: [PATCH 120/263] 1.x: Fix typo eigth to eighth (#4238)

---
 src/main/java/rx/Observable.java          | 2 +-
 src/main/java/rx/Single.java              | 4 ++--
 src/main/java/rx/functions/Action8.java   | 2 +-
 src/main/java/rx/functions/Action9.java   | 2 +-
 src/main/java/rx/functions/Actions.java   | 8 ++++----
 src/main/java/rx/functions/Func8.java     | 2 +-
 src/main/java/rx/functions/Func9.java     | 2 +-
 src/main/java/rx/functions/Functions.java | 4 ++--
 8 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 4cbf28d18e..b7207c9ec7 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -11763,7 +11763,7 @@ public final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> withLatestFrom(
      * @param <T5> the fifth other source's value type
      * @param <T6> the sixth other source's value type
      * @param <T7> the seventh other source's value type
-     * @param <T8> the eigth other source's value type
+     * @param <T8> the eighth other source's value type
      * @param <R> the result value type
      * @param o1 the first other Observable
      * @param o2 the second other Observable
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index c869225b3e..d61e1a9881 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -1213,7 +1213,7 @@ public R call(Object... args) {
      * @param <T5> the fifth source Single's value type
      * @param <T6> the sixth source Single's value type
      * @param <T7> the seventh source Single's value type
-     * @param <T8> the eigth source Single's value type
+     * @param <T8> the eighth source Single's value type
      * @param <R> the result value type
      * @param s1
      *            the first source Single
@@ -1265,7 +1265,7 @@ public R call(Object... args) {
      * @param <T5> the fifth source Single's value type
      * @param <T6> the sixth source Single's value type
      * @param <T7> the seventh source Single's value type
-     * @param <T8> the eigth source Single's value type
+     * @param <T8> the eighth source Single's value type
      * @param <T9> the ninth source Single's value type
      * @param <R> the result value type
      * @param s1
diff --git a/src/main/java/rx/functions/Action8.java b/src/main/java/rx/functions/Action8.java
index 86a09a3c97..97a7424677 100644
--- a/src/main/java/rx/functions/Action8.java
+++ b/src/main/java/rx/functions/Action8.java
@@ -24,7 +24,7 @@
  * @param <T5> the fifth argument type
  * @param <T6> the sixth argument type
  * @param <T7> the seventh argument type
- * @param <T8> the eigth argument type
+ * @param <T8> the eighth argument type
  */
 public interface Action8<T1, T2, T3, T4, T5, T6, T7, T8> extends Action {
     void call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8);
diff --git a/src/main/java/rx/functions/Action9.java b/src/main/java/rx/functions/Action9.java
index acb0c83c26..c23761c610 100644
--- a/src/main/java/rx/functions/Action9.java
+++ b/src/main/java/rx/functions/Action9.java
@@ -24,7 +24,7 @@
  * @param <T5> the fifth argument type
  * @param <T6> the sixth argument type
  * @param <T7> the seventh argument type
- * @param <T8> the eigth argument type
+ * @param <T8> the eighth argument type
  * @param <T9> the ninth argument type
  */
 public interface Action9<T1, T2, T3, T4, T5, T6, T7, T8, T9> extends Action {
diff --git a/src/main/java/rx/functions/Actions.java b/src/main/java/rx/functions/Actions.java
index d204d16ebc..ec15d4152a 100644
--- a/src/main/java/rx/functions/Actions.java
+++ b/src/main/java/rx/functions/Actions.java
@@ -229,7 +229,7 @@ public static <T1, T2, T3, T4, T5, T6, T7> Func7<T1, T2, T3, T4, T5, T6, T7, Voi
      * @param <T5> the fifth argument type
      * @param <T6> the sixth argument type
      * @param <T7> the seventh argument type
-     * @param <T8> the eigth argument type
+     * @param <T8> the eighth argument type
      * @param action
      *            the {@link Action8} to convert
      * @return a {@link Func8} that calls {@code action} and returns {@code null}
@@ -249,7 +249,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> Func8<T1, T2, T3, T4, T5, T6, T7,
      * @param <T5> the fifth argument type
      * @param <T6> the sixth argument type
      * @param <T7> the seventh argument type
-     * @param <T8> the eigth argument type
+     * @param <T8> the eighth argument type
      * @param <T9> the ninth argument type
      * @param action
      *            the {@link Action9} to convert
@@ -473,7 +473,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) {
      * @param <T5> the fifth argument type
      * @param <T6> the sixth argument type
      * @param <T7> the seventh argument type
-     * @param <T8> the eigth argument type
+     * @param <T8> the eighth argument type
      * @param <R> the result type
      * @param action
      *            the {@link Action8} to convert
@@ -502,7 +502,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) {
      * @param <T5> the fifth argument type
      * @param <T6> the sixth argument type
      * @param <T7> the seventh argument type
-     * @param <T8> the eigth argument type
+     * @param <T8> the eighth argument type
      * @param <T9> the ninth argument type
      * @param <R> the result type
      * @param action
diff --git a/src/main/java/rx/functions/Func8.java b/src/main/java/rx/functions/Func8.java
index a64df6806e..5e0e31c9c9 100644
--- a/src/main/java/rx/functions/Func8.java
+++ b/src/main/java/rx/functions/Func8.java
@@ -24,7 +24,7 @@
  * @param <T5> the fifth argument type
  * @param <T6> the sixth argument type
  * @param <T7> the seventh argument type
- * @param <T8> the eigth argument type
+ * @param <T8> the eighth argument type
  * @param <R> the result type
  */
 public interface Func8<T1, T2, T3, T4, T5, T6, T7, T8, R> extends Function {
diff --git a/src/main/java/rx/functions/Func9.java b/src/main/java/rx/functions/Func9.java
index 35c96f93f3..0e8e090cbf 100644
--- a/src/main/java/rx/functions/Func9.java
+++ b/src/main/java/rx/functions/Func9.java
@@ -24,7 +24,7 @@
  * @param <T5> the fifth argument type
  * @param <T6> the sixth argument type
  * @param <T7> the seventh argument type
- * @param <T8> the eigth argument type
+ * @param <T8> the eighth argument type
  * @param <T9> the ninth argument type
  * @param <R> the result type
  */
diff --git a/src/main/java/rx/functions/Functions.java b/src/main/java/rx/functions/Functions.java
index 24036ec498..31999f45e7 100644
--- a/src/main/java/rx/functions/Functions.java
+++ b/src/main/java/rx/functions/Functions.java
@@ -241,7 +241,7 @@ public R call(Object... args) {
      * @param <T4> the fifth argument type
      * @param <T5> the sixth argument type
      * @param <T6> the seventh argument type
-     * @param <T7> the eigth argument type
+     * @param <T7> the eighth argument type
      * @param <R> the result type
      * @param f
      *          the {@code Func8} to convert
@@ -272,7 +272,7 @@ public R call(Object... args) {
      * @param <T4> the fifth argument type
      * @param <T5> the sixth argument type
      * @param <T6> the seventh argument type
-     * @param <T7> the eigth argument type
+     * @param <T7> the eighth argument type
      * @param <T8> the ninth argument type
      * @param <R> the result type
      * @param f

From ec77334731d5a8ed736729eae43511586338c40a Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Wed, 27 Jul 2016 17:25:27 +1000
Subject: [PATCH 121/263] rename Map and Filter test classes now that have
 moved to OnSubscribe (#4243)

---
 .../{OperatorFilterTest.java => OnSubscribeFilterTest.java}     | 2 +-
 .../operators/{OperatorMapTest.java => OnSubscribeMapTest.java} | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename src/test/java/rx/internal/operators/{OperatorFilterTest.java => OnSubscribeFilterTest.java} (99%)
 rename src/test/java/rx/internal/operators/{OperatorMapTest.java => OnSubscribeMapTest.java} (99%)

diff --git a/src/test/java/rx/internal/operators/OperatorFilterTest.java b/src/test/java/rx/internal/operators/OnSubscribeFilterTest.java
similarity index 99%
rename from src/test/java/rx/internal/operators/OperatorFilterTest.java
rename to src/test/java/rx/internal/operators/OnSubscribeFilterTest.java
index 5a8ebeb9f6..73d91f8f02 100644
--- a/src/test/java/rx/internal/operators/OperatorFilterTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFilterTest.java
@@ -30,7 +30,7 @@
 import rx.observers.TestSubscriber;
 import rx.subjects.PublishSubject;
 
-public class OperatorFilterTest {
+public class OnSubscribeFilterTest {
 
     @Test
     public void testFilter() {
diff --git a/src/test/java/rx/internal/operators/OperatorMapTest.java b/src/test/java/rx/internal/operators/OnSubscribeMapTest.java
similarity index 99%
rename from src/test/java/rx/internal/operators/OperatorMapTest.java
rename to src/test/java/rx/internal/operators/OnSubscribeMapTest.java
index d13439b5de..821ed4f09e 100644
--- a/src/test/java/rx/internal/operators/OperatorMapTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeMapTest.java
@@ -32,7 +32,7 @@
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
 
-public class OperatorMapTest {
+public class OnSubscribeMapTest {
 
     @Mock
     Observer<String> stringObserver;

From 3467685796f76b90857b97030c9f4a2fbab45c46 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Wed, 27 Jul 2016 17:48:08 +1000
Subject: [PATCH 122/263] save allocation in OperatorSkipTimed (#4239)

* save allocation in OperatorSkipTimed

* fix unsub, add unit test
---
 src/main/java/rx/Observable.java              |  2 +-
 .../operators/OnSubscribeSkipTimed.java       | 94 +++++++++++++++++++
 .../internal/operators/OperatorSkipTimed.java | 80 ----------------
 .../operators/OperatorSkipTimedTest.java      | 27 ++++++
 4 files changed, 122 insertions(+), 81 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeSkipTimed.java
 delete mode 100644 src/main/java/rx/internal/operators/OperatorSkipTimed.java

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index b7207c9ec7..1aeed4c6a9 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -9203,7 +9203,7 @@ public final Observable<T> skip(long time, TimeUnit unit) {
      * @see <a href="http://reactivex.io/documentation/operators/skip.html">ReactiveX operators documentation: Skip</a>
      */
     public final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler) {
-        return lift(new OperatorSkipTimed<T>(time, unit, scheduler));
+        return create(new OnSubscribeSkipTimed<T>(this, time, unit, scheduler));
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeSkipTimed.java b/src/main/java/rx/internal/operators/OnSubscribeSkipTimed.java
new file mode 100644
index 0000000000..b9f47d2c7a
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeSkipTimed.java
@@ -0,0 +1,94 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.TimeUnit;
+
+import rx.Observable.OnSubscribe;
+import rx.Observable;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.Subscriber;
+import rx.functions.Action0;
+
+/**
+ * Skips elements until a specified time elapses.
+ * @param <T> the value type
+ */
+public final class OnSubscribeSkipTimed<T> implements OnSubscribe<T> {
+    final long time;
+    final TimeUnit unit;
+    final Scheduler scheduler;
+    final Observable<T> source;
+
+    public OnSubscribeSkipTimed(Observable<T> source, long time, TimeUnit unit, Scheduler scheduler) {
+        this.source = source;
+        this.time = time;
+        this.unit = unit;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public void call(final Subscriber<? super T> child) {
+        final Worker worker = scheduler.createWorker();
+        SkipTimedSubscriber<T> subscriber = new SkipTimedSubscriber<T>(child);
+        subscriber.add(worker);
+        child.add(subscriber);
+        worker.schedule(subscriber, time, unit);
+        source.unsafeSubscribe(subscriber);
+    }
+    
+    final static class SkipTimedSubscriber<T> extends Subscriber<T> implements Action0 {
+
+        final Subscriber<? super T> child;
+        volatile boolean gate;
+
+        SkipTimedSubscriber(Subscriber<? super T> child) {
+            this.child = child;
+        }
+
+        @Override
+        public void call() {
+            gate = true;
+        }
+        
+        @Override
+        public void onNext(T t) {
+            if (gate) {
+                child.onNext(t);
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            try {
+                child.onError(e);
+            } finally {
+                unsubscribe();
+            }
+        }
+
+        @Override
+        public void onCompleted() {
+            try {
+                child.onCompleted();
+            } finally {
+                unsubscribe();
+            }
+        }
+        
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OperatorSkipTimed.java b/src/main/java/rx/internal/operators/OperatorSkipTimed.java
deleted file mode 100644
index 78a527ef94..0000000000
--- a/src/main/java/rx/internal/operators/OperatorSkipTimed.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- *
- * 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 rx.internal.operators;
-
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import rx.*;
-import rx.Observable.Operator;
-import rx.Scheduler.Worker;
-import rx.functions.Action0;
-
-/**
- * Skips elements until a specified time elapses.
- * @param <T> the value type
- */
-public final class OperatorSkipTimed<T> implements Operator<T, T> {
-    final long time;
-    final TimeUnit unit;
-    final Scheduler scheduler;
-
-    public OperatorSkipTimed(long time, TimeUnit unit, Scheduler scheduler) {
-        this.time = time;
-        this.unit = unit;
-        this.scheduler = scheduler;
-    }
-
-    @Override
-    public Subscriber<? super T> call(final Subscriber<? super T> child) {
-        final Worker worker = scheduler.createWorker();
-        child.add(worker);
-        final AtomicBoolean gate = new AtomicBoolean();
-        worker.schedule(new Action0() {
-            @Override
-            public void call() {
-                gate.set(true);
-            }
-        }, time, unit);
-        return new Subscriber<T>(child) {
-
-            @Override
-            public void onNext(T t) {
-                if (gate.get()) {
-                    child.onNext(t);
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                try {
-                    child.onError(e);
-                } finally {
-                    unsubscribe();
-                }
-            }
-
-            @Override
-            public void onCompleted() {
-                try {
-                    child.onCompleted();
-                } finally {
-                    unsubscribe();
-                }
-            }
-        };
-    }
-}
diff --git a/src/test/java/rx/internal/operators/OperatorSkipTimedTest.java b/src/test/java/rx/internal/operators/OperatorSkipTimedTest.java
index b75c84eef8..1e83be8017 100644
--- a/src/test/java/rx/internal/operators/OperatorSkipTimedTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSkipTimedTest.java
@@ -15,6 +15,7 @@
  */
 package rx.internal.operators;
 
+import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
@@ -22,6 +23,7 @@
 import static org.mockito.Mockito.verify;
 
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -29,6 +31,8 @@
 import rx.Observable;
 import rx.Observer;
 import rx.exceptions.TestException;
+import rx.functions.Action0;
+import rx.observers.TestSubscriber;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -166,4 +170,27 @@ public void testSkipTimedErrorAfterTime() {
         verify(o, never()).onCompleted();
 
     }
+    
+    @Test
+    public void testSkipTimedUnsubscribePropagatesToUpstream() {
+        TestScheduler scheduler = new TestScheduler();
+
+        PublishSubject<Integer> source = PublishSubject.create();
+
+        final AtomicBoolean unsub = new AtomicBoolean();
+        Observable<Integer> result = source.doOnUnsubscribe(new Action0() {
+
+            @Override
+            public void call() {
+                unsub.set(true);
+            }
+        }).skip(1, TimeUnit.SECONDS, scheduler);
+
+        TestSubscriber<Object> ts = TestSubscriber.create();
+
+        result.subscribe(ts);
+        source.onNext(1);
+        ts.unsubscribe();
+        assertTrue(unsub.get());
+    }
 }

From c566a40710ecba32b58fb7900a72dfc18c9fb901 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 27 Jul 2016 10:15:30 +0200
Subject: [PATCH 123/263] jgit freaks out if it can't find a version tag

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index aa7f0cee15..4ecbec4dfa 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,7 +5,7 @@ sudo: false
 # as per http://blog.travis-ci.com/2014-12-17-faster-builds-with-container-based-infrastructure/
 
 git:
-  depth: 10
+  depth: 20
 
 # prevent travis running gradle assemble; let the build script do it anyway
 install: true

From 1e147fb629c76b39f795ce79791725a52187899f Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Wed, 27 Jul 2016 17:47:21 +0200
Subject: [PATCH 124/263] 1.x: SyncOnSubscribe fix typo and java doc (#4248)

---
 src/main/java/rx/observables/SyncOnSubscribe.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/observables/SyncOnSubscribe.java b/src/main/java/rx/observables/SyncOnSubscribe.java
index 6876b1ef31..2cbcba438e 100644
--- a/src/main/java/rx/observables/SyncOnSubscribe.java
+++ b/src/main/java/rx/observables/SyncOnSubscribe.java
@@ -27,7 +27,7 @@
 import rx.plugins.RxJavaHooks;
 
 /**
- * A utility class to create {@code OnSubscribe<T>} functions that respond correctly to back
+ * A utility class to create {@code OnSubscribe<T>} functions that responds correctly to back
  * pressure requests from subscribers. This is an improvement over
  * {@link rx.Observable#create(OnSubscribe) Observable.create(OnSubscribe)} which does not provide
  * any means of managing back pressure requests out-of-the-box.
@@ -271,7 +271,7 @@ public void call(Void t) {
 
     /**
      * An implementation of SyncOnSubscribe that delegates
-     * {@link SyncOnSubscribe#next(Object, Subscriber)}, {@link SyncOnSubscribe#generateState()},
+     * {@link SyncOnSubscribe#next(Object, Observer)}, {@link SyncOnSubscribe#generateState()},
      * and {@link SyncOnSubscribe#onUnsubscribe(Object)} to provided functions/closures.
      *
      * @param <S>

From 7e913faf9403323ae8bdc291879f1fba369f0536 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Wed, 27 Jul 2016 22:58:07 +0200
Subject: [PATCH 125/263] 1.x: Single.flatMapCompletable (#4226)

* 1.x: Single.flatMapCompletable

* Add documentation and CompletableFlatMapSingleToCompletable

* Add Generic

* Add ? extends Completable

* Add @Experimental

* Add Java Doc link

* Change test for artem
---
 src/main/java/rx/Single.java                  | 23 +++++
 ...CompletableFlatMapSingleToCompletable.java | 92 +++++++++++++++++++
 src/test/java/rx/SingleTest.java              | 64 +++++++++++++
 3 files changed, 179 insertions(+)
 create mode 100644 src/main/java/rx/internal/operators/CompletableFlatMapSingleToCompletable.java

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index d61e1a9881..c1a89043a6 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -1396,6 +1396,29 @@ public final <R> Observable<R> flatMapObservable(Func1<? super T, ? extends Obse
         return Observable.merge(asObservable(map(func)));
     }
 
+    /**
+     * Returns a {@link Completable} that completes based on applying a specified function to the item emitted by the
+     * source {@link Completable}, where that function returns a {@link Completable}.
+     * <p>
+     * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Single.flatMapCompletable.png" alt="">
+     * <dl>
+     * <dt><b>Scheduler:</b></dt>
+     * <dd>{@code flatMapCompletable} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param func
+     *            a function that, when applied to the item emitted by the source Single, returns a
+     *            Completable
+     * @return the Completable returned from {@code func} when applied to the item emitted by the source Single
+     * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
+     * @Experimental The behavior of this can change at any time.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final Completable flatMapCompletable(final Func1<? super T, ? extends Completable> func) {
+        return Completable.create(new CompletableFlatMapSingleToCompletable<T>(this, func));
+    }
+
     /**
      * Returns a Single that applies a specified function to the item emitted by the source Single and
      * emits the result of this function application.
diff --git a/src/main/java/rx/internal/operators/CompletableFlatMapSingleToCompletable.java b/src/main/java/rx/internal/operators/CompletableFlatMapSingleToCompletable.java
new file mode 100644
index 0000000000..f5d0a44123
--- /dev/null
+++ b/src/main/java/rx/internal/operators/CompletableFlatMapSingleToCompletable.java
@@ -0,0 +1,92 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.Completable;
+import rx.Completable.CompletableOnSubscribe;
+import rx.Completable.CompletableSubscriber;
+import rx.Single;
+import rx.SingleSubscriber;
+import rx.Subscription;
+import rx.exceptions.Exceptions;
+import rx.functions.Func1;
+
+public final class CompletableFlatMapSingleToCompletable<T> implements CompletableOnSubscribe {
+
+    final Single<T> source;
+
+    final Func1<? super T, ? extends Completable> mapper;
+
+    public CompletableFlatMapSingleToCompletable(Single<T> source, Func1<? super T, ? extends Completable> mapper) {
+        this.source = source;
+        this.mapper = mapper;
+    }
+
+    @Override
+    public void call(CompletableSubscriber t) {
+        SourceSubscriber<T> parent = new SourceSubscriber<T>(t, mapper);
+        t.onSubscribe(parent);
+        source.subscribe(parent);
+    }
+
+    static final class SourceSubscriber<T> extends SingleSubscriber<T> implements CompletableSubscriber {
+        final CompletableSubscriber actual;
+
+        final Func1<? super T, ? extends Completable> mapper;
+
+        public SourceSubscriber(CompletableSubscriber actual, Func1<? super T, ? extends Completable> mapper) {
+            this.actual = actual;
+            this.mapper = mapper;
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            Completable c;
+
+            try {
+                c = mapper.call(value);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                onError(ex);
+                return;
+            }
+
+            if (c == null) {
+                onError(new NullPointerException("The mapper returned a null Completable"));
+                return;
+            }
+
+            c.subscribe(this);
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            actual.onError(error);
+        }
+
+        @Override
+        public void onCompleted() {
+            actual.onCompleted();
+        }
+
+        @Override
+        public void onSubscribe(Subscription d) {
+            add(d);
+        }
+    }
+
+}
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index 7f45192044..375feafc7e 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -2005,4 +2005,68 @@ public Single<Integer> call(Integer v) {
         assertFalse("Observers present?!", ps.hasObservers());
     }
 
+    @Test
+    public void flatMapCompletableComplete() {
+        final AtomicInteger atomicInteger = new AtomicInteger();
+        TestSubscriber testSubscriber = TestSubscriber.create();
+
+        Single.just(1).flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(final Integer integer) {
+                return Completable.fromAction(new Action0() {
+                    @Override
+                    public void call() {
+                        atomicInteger.set(5);
+                    }
+                });
+            }
+        }).subscribe(testSubscriber);
+
+        testSubscriber.assertCompleted();
+
+        assertEquals(5, atomicInteger.get());
+    }
+
+    @Test
+    public void flatMapCompletableError() {
+        final RuntimeException error = new RuntimeException("some error");
+        TestSubscriber testSubscriber = TestSubscriber.create();
+
+        Single.just(1).flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(final Integer integer) {
+                return Completable.error(error);
+            }
+        }).subscribe(testSubscriber);
+
+        testSubscriber.assertError(error);
+    }
+
+    @Test
+    public void flatMapCompletableNullCompletable() {
+        TestSubscriber testSubscriber = TestSubscriber.create();
+
+        Single.just(1).flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(final Integer integer) {
+                return null;
+            }
+        }).subscribe(testSubscriber);
+
+        testSubscriber.assertError(NullPointerException.class);
+    }
+
+    @Test
+    public void flatMapCompletableException() {
+        TestSubscriber testSubscriber = TestSubscriber.create();
+
+        Single.just(1).flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(final Integer integer) {
+                throw new UnsupportedOperationException();
+            }
+        }).subscribe(testSubscriber);
+
+        testSubscriber.assertError(UnsupportedOperationException.class);
+    }
 }

From e697309b3d84b93fdeb07c520ca97342e97b8afa Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Thu, 28 Jul 2016 07:05:28 +1000
Subject: [PATCH 126/263] OperatorAll - prevent multiple terminal events
 (#4244)

---
 .../rx/internal/operators/OperatorAll.java    |  13 +-
 .../internal/operators/OperatorAllTest.java   | 114 ++++++++++++++++++
 2 files changed, 125 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorAll.java b/src/main/java/rx/internal/operators/OperatorAll.java
index 48053ed710..c9ef535dbd 100644
--- a/src/main/java/rx/internal/operators/OperatorAll.java
+++ b/src/main/java/rx/internal/operators/OperatorAll.java
@@ -20,6 +20,7 @@
 import rx.exceptions.Exceptions;
 import rx.functions.Func1;
 import rx.internal.producers.SingleDelayedProducer;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Returns an Observable that emits a Boolean that indicates whether all items emitted by an
@@ -43,6 +44,9 @@ public Subscriber<? super T> call(final Subscriber<? super Boolean> child) {
 
             @Override
             public void onNext(T t) {
+                if (done) {
+                    return;
+                }
                 Boolean result;
                 try {
                     result = predicate.call(t);
@@ -50,7 +54,7 @@ public void onNext(T t) {
                     Exceptions.throwOrReport(e, this, t);
                     return;
                 }
-                if (!result && !done) {
+                if (!result) {
                     done = true;
                     producer.setValue(false);
                     unsubscribe();
@@ -61,7 +65,12 @@ public void onNext(T t) {
 
             @Override
             public void onError(Throwable e) {
-                child.onError(e);
+                if (!done) {
+                    done = true;
+                    child.onError(e);
+                } else {
+                    RxJavaHooks.onError(e);
+                }
             }
 
             @Override
diff --git a/src/test/java/rx/internal/operators/OperatorAllTest.java b/src/test/java/rx/internal/operators/OperatorAllTest.java
index 1fd84bc129..4bac172aae 100644
--- a/src/test/java/rx/internal/operators/OperatorAllTest.java
+++ b/src/test/java/rx/internal/operators/OperatorAllTest.java
@@ -20,13 +20,17 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.TimeUnit;
 
 import org.junit.Test;
 
 import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
 
 public class OperatorAllTest {
 
@@ -178,4 +182,114 @@ public Boolean call(Object object) {
         assertEquals(ex, errors.get(0));
         assertTrue(ex.getCause().getMessage().contains("Boo!"));
     }
+    
+    @Test
+    public void testDoesNotEmitMultipleTerminalEvents() {
+        TestSubscriber<Boolean> ts = TestSubscriber.create();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 0) {
+                            sub.onNext(1);
+                            sub.onCompleted();
+                        }
+                    }
+                });
+            }
+        })
+        .all(new Func1<Integer,Boolean>() {
+
+            @Override
+            public Boolean call(Integer t) {
+                throw new RuntimeException("boo");
+            }})
+        .unsafeSubscribe(ts);
+        ts.assertError(RuntimeException.class);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testUpstreamEmitsOnNextAfterFailureWithoutCheckingSubscription() {
+        TestSubscriber<Boolean> ts = TestSubscriber.create();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 1) {
+                            sub.onNext(1);
+                            sub.onNext(2);
+                        }
+                    }
+                });
+            }
+        })
+        .all(new Func1<Integer,Boolean>() {
+            boolean once = true;
+            @Override
+            public Boolean call(Integer t) {
+                if (once)
+                    throw new RuntimeException("boo");
+                else  {
+                    once = false;
+                    return true; 
+                }
+            }})
+        .unsafeSubscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(RuntimeException.class);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testDoesNotEmitMultipleErrorEventsAndReportsSecondErrorToHooks() {
+        try {
+            final List<Throwable> list = new CopyOnWriteArrayList<Throwable>();
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+
+                @Override
+                public void call(Throwable t) {
+                    list.add(t);
+                }
+            });
+            TestSubscriber<Boolean> ts = TestSubscriber.create();
+            final RuntimeException e1 = new RuntimeException();
+            final Throwable e2 = new RuntimeException();
+            Observable.create(new OnSubscribe<Integer>() {
+
+                @Override
+                public void call(final Subscriber<? super Integer> sub) {
+                    sub.setProducer(new Producer() {
+
+                        @Override
+                        public void request(long n) {
+                            if (n > 0) {
+                                sub.onNext(1);
+                                sub.onError(e2);
+                            }
+                        }
+                    });
+                }
+            }).all(new Func1<Integer, Boolean>() {
+
+                @Override
+                public Boolean call(Integer t) {
+                    throw e1;
+                }
+            }).unsafeSubscribe(ts);
+            ts.assertNotCompleted();
+            assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
+            assertEquals(Arrays.asList(e2), list);
+        } finally {
+            RxJavaHooks.setOnError(null);
+        }
+    }
 }

From d6f395e20d3f3690fadd47613eb8406bd19d02b8 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 27 Jul 2016 23:07:54 +0200
Subject: [PATCH 127/263] Fix retryWhen/redoWhen potential concurrent reentry
 when resubscribing (#4241)

---
 src/main/java/rx/internal/operators/OnSubscribeRedo.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OnSubscribeRedo.java b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
index b258519fdf..06830122ff 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRedo.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
@@ -41,7 +41,7 @@
 import rx.internal.producers.ProducerArbiter;
 import rx.observers.Subscribers;
 import rx.schedulers.Schedulers;
-import rx.subjects.BehaviorSubject;
+import rx.subjects.*;
 import rx.subscriptions.SerialSubscription;
 
 public final class OnSubscribeRedo<T> implements OnSubscribe<T> {
@@ -202,7 +202,7 @@ public void call(final Subscriber<? super T> child) {
         // the source observable. We use a BehaviorSubject because subscribeToSource 
         // may emit a terminal before the restarts observable (transformed terminals) 
         // is subscribed
-        final BehaviorSubject<Notification<?>> terminals = BehaviorSubject.create();
+        final Subject<Notification<?>, Notification<?>> terminals = BehaviorSubject.<Notification<?>>create().toSerialized();
         final Subscriber<Notification<?>> dummySubscriber = Subscribers.empty();
         // subscribe immediately so the last emission will be replayed to the next 
         // subscriber (which is the one we care about)

From b72befff08b935ed4652582e17ce658246c12b2c Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 27 Jul 2016 23:08:36 +0200
Subject: [PATCH 128/263] 1.x: PublishSubject fail-fast when backpressured
 (#4225)

* 1.x: PublishSubject fail-fast when backpressured

* Inline get(), use smaller error array at first.
---
 src/main/java/rx/subjects/PublishSubject.java | 284 ++++++++++++++----
 .../OperatorMapNotificationTest.java          |   9 +-
 .../OperatorPublishFunctionTest.java          |   4 +-
 .../internal/operators/OperatorTakeTest.java  |   4 +-
 .../java/rx/subjects/PublishSubjectTest.java  |  64 +++-
 5 files changed, 303 insertions(+), 62 deletions(-)

diff --git a/src/main/java/rx/subjects/PublishSubject.java b/src/main/java/rx/subjects/PublishSubject.java
index 90fae91c00..5072a3d6e7 100644
--- a/src/main/java/rx/subjects/PublishSubject.java
+++ b/src/main/java/rx/subjects/PublishSubject.java
@@ -16,13 +16,13 @@
 package rx.subjects;
 
 import java.util.*;
+import java.util.concurrent.atomic.*;
 
+import rx.*;
 import rx.Observer;
 import rx.annotations.Beta;
-import rx.exceptions.Exceptions;
-import rx.functions.Action1;
-import rx.internal.operators.NotificationLite;
-import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
+import rx.exceptions.*;
+import rx.internal.operators.BackpressureUtils;
 
 /**
  * Subject that, once an {@link Observer} has subscribed, emits all subsequently observed items to the
@@ -50,8 +50,8 @@
  *          the type of items observed and emitted by the Subject
  */
 public final class PublishSubject<T> extends Subject<T, T> {
-    final SubjectSubscriptionManager<T> state;
-    private final NotificationLite<T> nl = NotificationLite.instance();
+
+    final PublishSubjectState<T> state;
 
     /**
      * Creates and returns a new {@code PublishSubject}.
@@ -60,63 +60,33 @@ public final class PublishSubject<T> extends Subject<T, T> {
      * @return the new {@code PublishSubject}
      */
     public static <T> PublishSubject<T> create() {
-        final SubjectSubscriptionManager<T> state = new SubjectSubscriptionManager<T>();
-        state.onTerminated = new Action1<SubjectObserver<T>>() {
-
-            @Override
-            public void call(SubjectObserver<T> o) {
-                o.emitFirst(state.getLatest(), state.nl);
-            }
-            
-        };
-        return new PublishSubject<T>(state, state);
+        return new PublishSubject<T>(new PublishSubjectState<T>());
     }
-
-    protected PublishSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> state) {
-        super(onSubscribe);
+    
+    protected PublishSubject(PublishSubjectState<T> state) {
+        super(state);
         this.state = state;
     }
 
     @Override
-    public void onCompleted() {
-        if (state.active) {
-            Object n = nl.completed();
-            for (SubjectObserver<T> bo : state.terminate(n)) {
-                bo.emitNext(n, state.nl);
-            }
-        }
-
+    public void onNext(T v) {
+        state.onNext(v);
     }
 
     @Override
-    public void onError(final Throwable e) {
-        if (state.active) {
-            Object n = nl.error(e);
-            List<Throwable> errors = null;
-            for (SubjectObserver<T> bo : state.terminate(n)) {
-                try {
-                    bo.emitNext(n, state.nl);
-                } catch (Throwable e2) {
-                    if (errors == null) {
-                        errors = new ArrayList<Throwable>();
-                    }
-                    errors.add(e2);
-                }
-            }
-            Exceptions.throwIfAny(errors);
-        }
+    public void onError(Throwable e) {
+        state.onError(e);
     }
 
     @Override
-    public void onNext(T v) {
-        for (SubjectObserver<T> bo : state.observers()) {
-            bo.onNext(v);
-        }
+    public void onCompleted() {
+        state.onCompleted();
     }
 
+
     @Override
     public boolean hasObservers() {
-        return state.observers().length > 0;
+        return state.get().length != 0;
     }
     
     /**
@@ -125,8 +95,7 @@ public boolean hasObservers() {
      */
     @Beta
     public boolean hasThrowable() {
-        Object o = state.getLatest();
-        return nl.isError(o);
+        return state.get() == PublishSubjectState.TERMINATED && state.error != null;
     }
     /**
      * Check if the Subject has terminated normally.
@@ -134,8 +103,7 @@ public boolean hasThrowable() {
      */
     @Beta
     public boolean hasCompleted() {
-        Object o = state.getLatest();
-        return o != null && !nl.isError(o);
+        return state.get() == PublishSubjectState.TERMINATED && state.error == null;
     }
     /**
      * Returns the Throwable that terminated the Subject.
@@ -144,10 +112,216 @@ public boolean hasCompleted() {
      */
     @Beta
     public Throwable getThrowable() {
-        Object o = state.getLatest();
-        if (nl.isError(o)) {
-            return nl.getError(o);
+        if (state.get() == PublishSubjectState.TERMINATED) {
+            return state.error;
         }
         return null;
     }
+    
+    static final class PublishSubjectState<T> 
+    extends AtomicReference<PublishSubjectProducer<T>[]>
+    implements OnSubscribe<T>, Observer<T> {
+
+        /** */
+        private static final long serialVersionUID = -7568940796666027140L;
+        
+        @SuppressWarnings("rawtypes")
+        static final PublishSubjectProducer[] EMPTY = new PublishSubjectProducer[0]; 
+        @SuppressWarnings("rawtypes")
+        static final PublishSubjectProducer[] TERMINATED = new PublishSubjectProducer[0]; 
+        
+        Throwable error;
+        
+        @SuppressWarnings("unchecked")
+        public PublishSubjectState() {
+            lazySet(EMPTY);
+        }
+        
+        @Override
+        public void call(Subscriber<? super T> t) {
+            PublishSubjectProducer<T> pp = new PublishSubjectProducer<T>(this, t);
+            t.add(pp);
+            t.setProducer(pp);
+            
+            if (add(pp)) {
+                if (pp.isUnsubscribed()) {
+                    remove(pp);
+                }
+            } else {
+                Throwable ex = error;
+                if (ex != null) {
+                    t.onError(ex);
+                } else {
+                    t.onCompleted();
+                }
+            }
+        }
+        
+        
+        boolean add(PublishSubjectProducer<T> inner) {
+            for (;;) {
+                PublishSubjectProducer<T>[] curr = get();
+                if (curr == TERMINATED) {
+                    return false;
+                }
+                
+                int n = curr.length;
+                
+                @SuppressWarnings("unchecked")
+                PublishSubjectProducer<T>[] next = new PublishSubjectProducer[n + 1];
+                System.arraycopy(curr, 0, next, 0, n);
+                
+                next[n] = inner;
+                if (compareAndSet(curr, next)) {
+                    return true;
+                }
+            }
+        }
+        
+        @SuppressWarnings("unchecked")
+        void remove(PublishSubjectProducer<T> inner) {
+            for (;;) {
+                PublishSubjectProducer<T>[] curr = get();
+                if (curr == TERMINATED || curr == EMPTY) {
+                    return;
+                }
+                
+                int n = curr.length;
+                int j = -1;
+                for (int i = 0; i < n; i++) {
+                    if (curr[i] == inner) {
+                        j = i;
+                        break;
+                    }
+                }
+                
+                if (j < 0) {
+                    return;
+                }
+                
+                PublishSubjectProducer<T>[] next;
+                if (n == 1) {
+                    next = EMPTY;
+                } else {
+                    next = new PublishSubjectProducer[n - 1];
+                    System.arraycopy(curr, 0, next, 0, j);
+                    System.arraycopy(curr, j + 1, next, j, n - j - 1);
+                }
+                
+                if (compareAndSet(curr, next)) {
+                    return;
+                }
+            }
+        }
+
+        @Override
+        public void onNext(T t) {
+            for (PublishSubjectProducer<T> pp : get()) {
+                pp.onNext(t);
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void onError(Throwable e) {
+            error = e;
+            List<Throwable> errors = null;
+            for (PublishSubjectProducer<T> pp : getAndSet(TERMINATED)) {
+                try {
+                    pp.onError(e);
+                } catch (Throwable ex) {
+                    if (errors == null) {
+                        errors = new ArrayList<Throwable>(1);
+                    }
+                    errors.add(ex);
+                }
+            }
+            
+            Exceptions.throwIfAny(errors);
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public void onCompleted() {
+            for (PublishSubjectProducer<T> pp : getAndSet(TERMINATED)) {
+                pp.onCompleted();
+            }
+        }
+
+    }
+    
+    static final class PublishSubjectProducer<T> 
+    extends AtomicLong
+    implements Producer, Subscription, Observer<T> {
+        /** */
+        private static final long serialVersionUID = 6451806817170721536L;
+
+        final PublishSubjectState<T> parent;
+        
+        final Subscriber<? super T> actual;
+        
+        long produced;
+        
+        public PublishSubjectProducer(PublishSubjectState<T> parent, Subscriber<? super T> actual) {
+            this.parent = parent;
+            this.actual = actual;
+        }
+        
+        @Override
+        public void request(long n) {
+            if (BackpressureUtils.validate(n)) {
+                for (;;) {
+                    long r = get();
+                    if (r == Long.MIN_VALUE) {
+                        return;
+                    }
+                    long u = BackpressureUtils.addCap(r, n);
+                    if (compareAndSet(r, u)) {
+                        return;
+                    }
+                }
+            }
+        }
+        
+        @Override
+        public boolean isUnsubscribed() {
+            return get() == Long.MIN_VALUE;
+        }
+        
+        @Override
+        public void unsubscribe() {
+            if (getAndSet(Long.MIN_VALUE) != Long.MIN_VALUE) {
+                parent.remove(this);
+            }
+        }
+        
+        @Override
+        public void onNext(T t) {
+            long r = get();
+            if (r != Long.MIN_VALUE) {
+                long p = produced;
+                if (r != p) {
+                    produced = p + 1;
+                    actual.onNext(t);
+                } else {
+                    unsubscribe();
+                    actual.onError(new MissingBackpressureException("PublishSubject: could not emit value due to lack of requests"));
+                }
+            }
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            if (get() != Long.MIN_VALUE) {
+                actual.onError(e);
+            }
+        }
+        
+        @Override
+        public void onCompleted() {
+            if (get() != Long.MIN_VALUE) {
+                actual.onCompleted();
+            }
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorMapNotificationTest.java b/src/test/java/rx/internal/operators/OperatorMapNotificationTest.java
index 3e94a20b8b..cd58bb2004 100644
--- a/src/test/java/rx/internal/operators/OperatorMapNotificationTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMapNotificationTest.java
@@ -132,9 +132,16 @@ public Integer call() {
         ps.onNext(3);
         ps.onCompleted();
         
-        ts.assertValues(2, 3, 4, 5);
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+        
+        ts.requestMore(1);
+        
+        ts.assertValue(0);
         ts.assertNoErrors();
         ts.assertCompleted();
+        
     }
 
 }
diff --git a/src/test/java/rx/internal/operators/OperatorPublishFunctionTest.java b/src/test/java/rx/internal/operators/OperatorPublishFunctionTest.java
index 0221c921ac..cbfa331977 100644
--- a/src/test/java/rx/internal/operators/OperatorPublishFunctionTest.java
+++ b/src/test/java/rx/internal/operators/OperatorPublishFunctionTest.java
@@ -222,7 +222,7 @@ public Observable<Integer> call(Observable<Integer> o) {
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
         
-        Assert.assertEquals("Queue full?!", ts.getOnErrorEvents().get(0).getMessage());
+        Assert.assertEquals("PublishSubject: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
         Assert.assertFalse("Source has subscribers?", ps.hasObservers());
     }
     
@@ -249,7 +249,7 @@ public Observable<Integer> call(Observable<Integer> o) {
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
         
-        Assert.assertEquals("Queue full?!", ts.getOnErrorEvents().get(0).getMessage());
+        Assert.assertEquals("PublishSubject: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
         Assert.assertFalse("Source has subscribers?", ps.hasObservers());
     }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorTakeTest.java b/src/test/java/rx/internal/operators/OperatorTakeTest.java
index df23a64150..efffdbccc1 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeTest.java
@@ -425,7 +425,9 @@ public void testReentrantTake() {
         
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         
-        source.take(1).doOnNext(new Action1<Integer>() {
+        source
+        .rebatchRequests(2) // take(1) requests 1
+        .take(1).doOnNext(new Action1<Integer>() {
             @Override
             public void call(Integer v) {
                 source.onNext(2);
diff --git a/src/test/java/rx/subjects/PublishSubjectTest.java b/src/test/java/rx/subjects/PublishSubjectTest.java
index 4dd974837a..e5f4ee647d 100644
--- a/src/test/java/rx/subjects/PublishSubjectTest.java
+++ b/src/test/java/rx/subjects/PublishSubjectTest.java
@@ -33,9 +33,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
-import rx.exceptions.CompositeException;
-import rx.exceptions.OnErrorNotImplementedException;
-import rx.exceptions.TestException;
+import rx.exceptions.*;
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.observers.TestSubscriber;
@@ -501,4 +499,64 @@ public void testPublishSubjectValueError() {
         assertTrue(async.hasThrowable());
         assertSame(te, async.getThrowable());
     }
+    
+    @Test
+    public void backpressureFailFast() {
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        TestSubscriber<Integer> ts = TestSubscriber.create(1);
+        
+        ps.subscribe(ts);
+        
+        ps.onNext(1);
+        
+        ts.assertValue(1);
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+        
+        ps.onNext(2);
+        
+        ts.assertValue(1);
+        ts.assertError(MissingBackpressureException.class);
+        ts.assertNotCompleted();
+
+        assertEquals("PublishSubject: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+    }
+    
+    @Test
+    public void crossUnsubscribe() {
+        PublishSubject<Integer> ps = PublishSubject.create();
+
+        final TestSubscriber<Integer> ts0 = TestSubscriber.create();
+
+        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                if (t == 2) {
+                    ts0.unsubscribe();
+                }
+            }
+        };
+        
+        ps.subscribe(ts1);
+        ps.subscribe(ts0);
+        
+        ps.onNext(1);
+        
+        ts0.assertValue(1);
+        ts1.assertValue(1);
+        
+        ps.onNext(2);
+        ps.onCompleted();
+        
+        ts0.assertValue(1);
+        ts0.assertNoErrors();
+        ts0.assertNotCompleted();
+        ts0.assertUnsubscribed();
+        
+        ts1.assertValues(1, 2);
+        ts1.assertNoErrors();
+        ts1.assertCompleted();
+    }
 }

From 689b22d9648822ca9a7fcce0f495b6ca28b663bf Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Thu, 28 Jul 2016 16:14:40 +1000
Subject: [PATCH 129/263] OperatorAny - prevent multiple terminal events
 (#4245)

---
 .../rx/internal/operators/OperatorAny.java    |  13 +-
 .../internal/operators/OperatorAnyTest.java   | 115 ++++++++++++++++++
 2 files changed, 126 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorAny.java b/src/main/java/rx/internal/operators/OperatorAny.java
index 9369b62b39..558bb005ac 100644
--- a/src/main/java/rx/internal/operators/OperatorAny.java
+++ b/src/main/java/rx/internal/operators/OperatorAny.java
@@ -21,6 +21,7 @@
 import rx.exceptions.Exceptions;
 import rx.functions.Func1;
 import rx.internal.producers.SingleDelayedProducer;
+import rx.plugins.RxJavaHooks;
 
 /**
  * Returns an {@link Observable} that emits <code>true</code> if any element of
@@ -45,6 +46,9 @@ public Subscriber<? super T> call(final Subscriber<? super Boolean> child) {
 
             @Override
             public void onNext(T t) {
+                if (done) {
+                    return;
+                }
                 hasElements = true;
                 boolean result;
                 try {
@@ -53,7 +57,7 @@ public void onNext(T t) {
                     Exceptions.throwOrReport(e, this, t);
                     return;
                 }
-                if (result && !done) {
+                if (result) {
                     done = true;
                     producer.setValue(!returnOnEmpty);
                     unsubscribe();
@@ -64,7 +68,12 @@ public void onNext(T t) {
 
             @Override
             public void onError(Throwable e) {
-                child.onError(e);
+                if (!done) {
+                    done = true;
+                    child.onError(e);
+                } else {
+                    RxJavaHooks.onError(e);
+                }
             }
 
             @Override
diff --git a/src/test/java/rx/internal/operators/OperatorAnyTest.java b/src/test/java/rx/internal/operators/OperatorAnyTest.java
index b48928d800..a9830c8a32 100644
--- a/src/test/java/rx/internal/operators/OperatorAnyTest.java
+++ b/src/test/java/rx/internal/operators/OperatorAnyTest.java
@@ -20,14 +20,18 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.TimeUnit;
 
 import org.junit.Test;
 
 import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.internal.util.UtilityFunctions;
 import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
 
 public class OperatorAnyTest {
 
@@ -270,4 +274,115 @@ public Boolean call(Object object) {
         assertEquals(ex, errors.get(0));
         assertTrue(ex.getCause().getMessage().contains("Boo!"));
     }
+    
+    @Test
+    public void testUpstreamEmitsOnNextAfterFailureWithoutCheckingSubscription() {
+        TestSubscriber<Boolean> ts = TestSubscriber.create();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 1) {
+                            sub.onNext(1);
+                            sub.onNext(2);
+                        }
+                    }
+                });
+            }
+        })
+        .exists(new Func1<Integer,Boolean>() {
+            boolean once = true;
+            @Override
+            public Boolean call(Integer t) {
+                if (once)
+                    throw new RuntimeException("boo");
+                else  {
+                    once = false;
+                    return true; 
+                }
+            }})
+        .unsafeSubscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(RuntimeException.class);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testUpstreamEmitsOnNextWithoutCheckingSubscription() {
+        TestSubscriber<Boolean> ts = TestSubscriber.create();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 1) {
+                            sub.onNext(1);
+                            sub.onNext(2);
+                            sub.onCompleted();
+                        }
+                    }
+                });
+            }
+        })
+        .exists(new Func1<Integer,Boolean>() {
+            @Override
+            public Boolean call(Integer t) {
+                return true;
+            }})
+        .unsafeSubscribe(ts);
+        ts.assertValue(true);
+        assertEquals(1, ts.getCompletions());
+        ts.assertNoErrors();
+    }
+    
+    @Test
+    public void testDoesNotEmitMultipleErrorEventsAndReportsSecondErrorToHooks() {
+        try {
+            final List<Throwable> list = new CopyOnWriteArrayList<Throwable>();
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+
+                @Override
+                public void call(Throwable t) {
+                    list.add(t);
+                }
+            });
+            TestSubscriber<Boolean> ts = TestSubscriber.create();
+            final RuntimeException e1 = new RuntimeException();
+            final Throwable e2 = new RuntimeException();
+            Observable.create(new OnSubscribe<Integer>() {
+
+                @Override
+                public void call(final Subscriber<? super Integer> sub) {
+                    sub.setProducer(new Producer() {
+
+                        @Override
+                        public void request(long n) {
+                            if (n > 0) {
+                                sub.onNext(1);
+                                sub.onError(e2);
+                            }
+                        }
+                    });
+                }
+            }).exists(new Func1<Integer, Boolean>() {
+
+                @Override
+                public Boolean call(Integer t) {
+                    throw e1;
+                }
+            }).unsafeSubscribe(ts);
+            ts.assertNotCompleted();
+            assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
+            assertEquals(Arrays.asList(e2), list);
+        } finally {
+            RxJavaHooks.setOnError(null);
+        }
+    }
 }

From 60dbbed758b02cc1de7d946c0e5eaa48e6f55193 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Thu, 28 Jul 2016 16:15:27 +1000
Subject: [PATCH 130/263] OperatorReduce - prevent multiple terminal events
 (#4246)

---
 .../internal/operators/OnSubscribeReduce.java |  19 +-
 .../operators/OnSubscribeReduceTest.java      | 277 ++++++++++++++++++
 .../operators/OperatorReduceTest.java         | 138 ---------
 3 files changed, 294 insertions(+), 140 deletions(-)
 create mode 100644 src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
 delete mode 100644 src/test/java/rx/internal/operators/OperatorReduceTest.java

diff --git a/src/main/java/rx/internal/operators/OnSubscribeReduce.java b/src/main/java/rx/internal/operators/OnSubscribeReduce.java
index ef910e88ac..5136aa376e 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeReduce.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeReduce.java
@@ -22,6 +22,7 @@
 import rx.Observable.OnSubscribe;
 import rx.exceptions.Exceptions;
 import rx.functions.Func2;
+import rx.plugins.RxJavaHooks;
 
 public final class OnSubscribeReduce<T> implements OnSubscribe<T> {
 
@@ -57,6 +58,8 @@ static final class ReduceSubscriber<T> extends Subscriber<T> {
         
         static final Object EMPTY = new Object();
         
+        boolean done;
+        
         @SuppressWarnings("unchecked")
         public ReduceSubscriber(Subscriber<? super T> actual, Func2<T, T, T> reducer) {
             this.actual = actual;
@@ -68,6 +71,9 @@ public ReduceSubscriber(Subscriber<? super T> actual, Func2<T, T, T> reducer) {
         @SuppressWarnings("unchecked")
         @Override
         public void onNext(T t) {
+            if (done) {
+                return;
+            }
             Object o = value;
             if (o == EMPTY) {
                 value = t;
@@ -77,19 +83,28 @@ public void onNext(T t) {
                 } catch (Throwable ex) {
                     Exceptions.throwIfFatal(ex);
                     unsubscribe();
-                    actual.onError(ex);
+                    onError(ex);
                 }
             }
         }
         
         @Override
         public void onError(Throwable e) {
-            actual.onError(e);
+            if (!done) {
+                done = true;
+                actual.onError(e);
+            } else {
+                RxJavaHooks.onError(e);
+            }
         }
         
         @SuppressWarnings("unchecked")
         @Override
         public void onCompleted() {
+            if (done) {
+                return;
+            }
+            done = true;
             Object o = value;
             if (o != EMPTY) {
                 actual.onNext((T)o);
diff --git a/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java b/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
new file mode 100644
index 0000000000..b09f92c158
--- /dev/null
+++ b/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
@@ -0,0 +1,277 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.Observer;
+import rx.exceptions.TestException;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.internal.util.UtilityFunctions;
+import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
+
+public class OnSubscribeReduceTest {
+    @Mock
+    Observer<Object> observer;
+
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    Func2<Integer, Integer, Integer> sum = new Func2<Integer, Integer, Integer>() {
+        @Override
+        public Integer call(Integer t1, Integer t2) {
+            return t1 + t2;
+        }
+    };
+
+    @Test
+    public void testAggregateAsIntSum() {
+
+        Observable<Integer> result = Observable.just(1, 2, 3, 4, 5).reduce(0, sum).map(UtilityFunctions.<Integer> identity());
+
+        result.subscribe(observer);
+
+        verify(observer).onNext(1 + 2 + 3 + 4 + 5);
+        verify(observer).onCompleted();
+        verify(observer, never()).onError(any(Throwable.class));
+    }
+
+    @Test
+    public void testAggregateAsIntSumSourceThrows() {
+        Observable<Integer> result = Observable.concat(Observable.just(1, 2, 3, 4, 5),
+                Observable.<Integer> error(new TestException()))
+                .reduce(0, sum).map(UtilityFunctions.<Integer> identity());
+
+        result.subscribe(observer);
+
+        verify(observer, never()).onNext(any());
+        verify(observer, never()).onCompleted();
+        verify(observer, times(1)).onError(any(TestException.class));
+    }
+
+    @Test
+    public void testAggregateAsIntSumAccumulatorThrows() {
+        Func2<Integer, Integer, Integer> sumErr = new Func2<Integer, Integer, Integer>() {
+            @Override
+            public Integer call(Integer t1, Integer t2) {
+                throw new TestException();
+            }
+        };
+
+        Observable<Integer> result = Observable.just(1, 2, 3, 4, 5)
+                .reduce(0, sumErr).map(UtilityFunctions.<Integer> identity());
+
+        result.subscribe(observer);
+
+        verify(observer, never()).onNext(any());
+        verify(observer, never()).onCompleted();
+        verify(observer, times(1)).onError(any(TestException.class));
+    }
+
+    @Test
+    public void testAggregateAsIntSumResultSelectorThrows() {
+
+        Func1<Integer, Integer> error = new Func1<Integer, Integer>() {
+
+            @Override
+            public Integer call(Integer t1) {
+                throw new TestException();
+            }
+        };
+
+        Observable<Integer> result = Observable.just(1, 2, 3, 4, 5)
+                .reduce(0, sum).map(error);
+
+        result.subscribe(observer);
+
+        verify(observer, never()).onNext(any());
+        verify(observer, never()).onCompleted();
+        verify(observer, times(1)).onError(any(TestException.class));
+    }
+
+    @Test
+    public void testBackpressureWithNoInitialValue() throws InterruptedException {
+        Observable<Integer> source = Observable.just(1, 2, 3, 4, 5, 6);
+        Observable<Integer> reduced = source.reduce(sum);
+
+        Integer r = reduced.toBlocking().first();
+        assertEquals(21, r.intValue());
+    }
+
+    @Test
+    public void testBackpressureWithInitialValue() throws InterruptedException {
+        Observable<Integer> source = Observable.just(1, 2, 3, 4, 5, 6);
+        Observable<Integer> reduced = source.reduce(0, sum);
+
+        Integer r = reduced.toBlocking().first();
+        assertEquals(21, r.intValue());
+    }
+    
+    @Test
+    public void testNoInitialValueDoesNotEmitMultipleTerminalEvents() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 0) {
+                            sub.onNext(1);
+                            sub.onNext(2);
+                            sub.onCompleted();
+                        }
+                    }
+                });
+            }
+        })
+        .reduce(new Func2<Integer, Integer, Integer>() {
+
+            @Override
+            public Integer call(Integer a, Integer b) {
+                throw new RuntimeException("boo");
+            }})
+        .unsafeSubscribe(ts);
+        ts.assertError(RuntimeException.class);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testNoInitialValueUpstreamEmitsMoreOnNextDespiteUnsubscription() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 2) {
+                            sub.onNext(1);
+                            sub.onNext(2);
+                            sub.onNext(3);
+                            sub.onCompleted();
+                        }
+                    }
+                });
+            }
+        })
+        .reduce(new Func2<Integer, Integer, Integer>() {
+            boolean once = true;
+            
+            @Override
+            public Integer call(Integer a, Integer b) {
+                if (once) {
+                    throw new RuntimeException("boo");
+                } else {
+                    once = false;
+                    return a + b;
+                }
+            }})
+        .unsafeSubscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(RuntimeException.class);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testNoInitialValueDoesNotEmitMultipleErrorEventsAndReportsSecondErrorToHooks() {
+        try {
+            final List<Throwable> list = new CopyOnWriteArrayList<Throwable>();
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+
+                @Override
+                public void call(Throwable t) {
+                    list.add(t);
+                }
+            });
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            final RuntimeException e1 = new RuntimeException("e1");
+            final Throwable e2 = new RuntimeException("e2");
+            Observable.create(new OnSubscribe<Integer>() {
+
+                @Override
+                public void call(final Subscriber<? super Integer> sub) {
+                    sub.setProducer(new Producer() {
+
+                        @Override
+                        public void request(long n) {
+                            if (n > 1) {
+                                sub.onNext(1);
+                                sub.onNext(2);
+                                sub.onError(e2);
+                            }
+                        }
+                    });
+                }
+            })
+            .reduce(new Func2<Integer, Integer, Integer>() {
+
+                @Override
+                public Integer call(Integer a, Integer b) {
+                    throw e1;
+            }})
+            .unsafeSubscribe(ts);
+            ts.assertNotCompleted();
+            System.out.println(ts.getOnErrorEvents());
+            assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
+            assertEquals(Arrays.asList(e2), list);
+        } finally {
+            RxJavaHooks.setOnError(null);
+        }
+    }
+
+    
+    @Test
+    public void testNoInitialValueEmitsNoSuchElementExceptionIfEmptyStream() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable.<Integer>empty().reduce(new Func2<Integer, Integer, Integer>() {
+
+            @Override
+            public Integer call(Integer a, Integer b) {
+                return a + b;
+            }
+        }).subscribe(ts);
+        ts.assertError(NoSuchElementException.class);
+    }
+
+
+}
diff --git a/src/test/java/rx/internal/operators/OperatorReduceTest.java b/src/test/java/rx/internal/operators/OperatorReduceTest.java
deleted file mode 100644
index c550c835ea..0000000000
--- a/src/test/java/rx/internal/operators/OperatorReduceTest.java
+++ /dev/null
@@ -1,138 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- * 
- * 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 rx.internal.operators;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-import rx.Observable;
-import rx.Observer;
-import rx.exceptions.TestException;
-import rx.functions.Func1;
-import rx.functions.Func2;
-import rx.internal.util.UtilityFunctions;
-
-public class OperatorReduceTest {
-    @Mock
-    Observer<Object> observer;
-
-    @Before
-    public void before() {
-        MockitoAnnotations.initMocks(this);
-    }
-
-    Func2<Integer, Integer, Integer> sum = new Func2<Integer, Integer, Integer>() {
-        @Override
-        public Integer call(Integer t1, Integer t2) {
-            return t1 + t2;
-        }
-    };
-
-    @Test
-    public void testAggregateAsIntSum() {
-
-        Observable<Integer> result = Observable.just(1, 2, 3, 4, 5).reduce(0, sum).map(UtilityFunctions.<Integer> identity());
-
-        result.subscribe(observer);
-
-        verify(observer).onNext(1 + 2 + 3 + 4 + 5);
-        verify(observer).onCompleted();
-        verify(observer, never()).onError(any(Throwable.class));
-    }
-
-    @Test
-    public void testAggregateAsIntSumSourceThrows() {
-        Observable<Integer> result = Observable.concat(Observable.just(1, 2, 3, 4, 5),
-                Observable.<Integer> error(new TestException()))
-                .reduce(0, sum).map(UtilityFunctions.<Integer> identity());
-
-        result.subscribe(observer);
-
-        verify(observer, never()).onNext(any());
-        verify(observer, never()).onCompleted();
-        verify(observer, times(1)).onError(any(TestException.class));
-    }
-
-    @Test
-    public void testAggregateAsIntSumAccumulatorThrows() {
-        Func2<Integer, Integer, Integer> sumErr = new Func2<Integer, Integer, Integer>() {
-            @Override
-            public Integer call(Integer t1, Integer t2) {
-                throw new TestException();
-            }
-        };
-
-        Observable<Integer> result = Observable.just(1, 2, 3, 4, 5)
-                .reduce(0, sumErr).map(UtilityFunctions.<Integer> identity());
-
-        result.subscribe(observer);
-
-        verify(observer, never()).onNext(any());
-        verify(observer, never()).onCompleted();
-        verify(observer, times(1)).onError(any(TestException.class));
-    }
-
-    @Test
-    public void testAggregateAsIntSumResultSelectorThrows() {
-
-        Func1<Integer, Integer> error = new Func1<Integer, Integer>() {
-
-            @Override
-            public Integer call(Integer t1) {
-                throw new TestException();
-            }
-        };
-
-        Observable<Integer> result = Observable.just(1, 2, 3, 4, 5)
-                .reduce(0, sum).map(error);
-
-        result.subscribe(observer);
-
-        verify(observer, never()).onNext(any());
-        verify(observer, never()).onCompleted();
-        verify(observer, times(1)).onError(any(TestException.class));
-    }
-
-    @Test
-    public void testBackpressureWithNoInitialValue() throws InterruptedException {
-        Observable<Integer> source = Observable.just(1, 2, 3, 4, 5, 6);
-        Observable<Integer> reduced = source.reduce(sum);
-
-        Integer r = reduced.toBlocking().first();
-        assertEquals(21, r.intValue());
-    }
-
-    @Test
-    public void testBackpressureWithInitialValue() throws InterruptedException {
-        Observable<Integer> source = Observable.just(1, 2, 3, 4, 5, 6);
-        Observable<Integer> reduced = source.reduce(0, sum);
-
-        Integer r = reduced.toBlocking().first();
-        assertEquals(21, r.intValue());
-    }
-
-
-
-}

From 41959f71b33e71b41c0d6130216e5e6a0f98bfb6 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Thu, 28 Jul 2016 16:16:16 +1000
Subject: [PATCH 131/263] onBackpressureDrop - prevent multiple terminal events
 (#4250)

---
 .../operators/OperatorOnBackpressureDrop.java |  21 ++-
 .../OperatorOnBackpressureDropTest.java       | 145 +++++++++++++++++-
 2 files changed, 162 insertions(+), 4 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
index c976fba197..80254abf57 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
@@ -21,6 +21,7 @@
 import rx.Observable.Operator;
 import rx.exceptions.Exceptions;
 import rx.functions.Action1;
+import rx.plugins.RxJavaHooks;
 
 public class OperatorOnBackpressureDrop<T> implements Operator<T, T> {
 
@@ -62,6 +63,9 @@ public void request(long n) {
 
         });
         return new Subscriber<T>(child) {
+            
+            boolean done;
+            
             @Override
             public void onStart() {
                 request(Long.MAX_VALUE);
@@ -69,16 +73,27 @@ public void onStart() {
 
             @Override
             public void onCompleted() {
-                child.onCompleted();
+                if (!done) {
+                    done = true;
+                    child.onCompleted();
+                }
             }
 
             @Override
             public void onError(Throwable e) {
-                child.onError(e);
+                if (!done) {
+                    done = true;
+                    child.onError(e);
+                } else {
+                   RxJavaHooks.onError(e);
+                }
             }
 
             @Override
             public void onNext(T t) {
+                if (done) {
+                    return;
+                }
                 if (requested.get() > 0) {
                     child.onNext(t);
                     requested.decrementAndGet();
@@ -88,7 +103,7 @@ public void onNext(T t) {
                         try {
                             onDrop.call(t);
                         } catch (Throwable e) {
-                            Exceptions.throwOrReport(e, child, t);
+                            Exceptions.throwOrReport(e, this, t);
                             return;
                         }
                     }
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
index 568ccfd985..c26df3e540 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
@@ -18,19 +18,24 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
 import rx.functions.Action1;
 import rx.internal.util.RxRingBuffer;
 import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.Schedulers;
 
 public class OperatorOnBackpressureDropTest {
@@ -141,6 +146,144 @@ public void call(Throwable t) {
         assertFalse(errorOccurred.get());
     }
     
+    @Test
+    public void testOnDropMethodIsCalled() {
+        final List<Integer> list = new ArrayList<Integer>();
+        // request 0
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 1) {
+                            sub.onNext(1);
+                            sub.onNext(2);
+                            sub.onCompleted();
+                        }
+                    }
+                });
+            }
+        }).onBackpressureDrop(new Action1<Integer>() {
+            @Override
+            public void call(Integer t) {
+                list.add(t);
+            }
+        }).subscribe(ts);
+        assertEquals(Arrays.asList(1, 2), list);
+    }
+    
+    @Test
+    public void testUpstreamEmitsOnCompletedAfterFailureWithoutCheckingSubscription() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        final RuntimeException e = new RuntimeException();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 1) {
+                            sub.onNext(1);
+                            sub.onCompleted();
+                        }
+                    }
+                });
+            }
+        })
+        .onBackpressureDrop(new Action1<Integer>() {
+            @Override
+            public void call(Integer t) {
+                throw e;
+            }})
+        .unsafeSubscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(e);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testUpstreamEmitsErrorAfterFailureWithoutCheckingSubscriptionResultsInHooksOnErrorCalled() {
+        try {
+            final List<Throwable> list = new CopyOnWriteArrayList<Throwable>();
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+
+                @Override
+                public void call(Throwable t) {
+                    list.add(t);
+                }
+            });
+            TestSubscriber<Integer> ts = TestSubscriber.create(0);
+            final RuntimeException e1 = new RuntimeException();
+            final RuntimeException e2 = new RuntimeException();
+            Observable.create(new OnSubscribe<Integer>() {
+
+                @Override
+                public void call(final Subscriber<? super Integer> sub) {
+                    sub.setProducer(new Producer() {
+
+                        @Override
+                        public void request(long n) {
+                            if (n > 1) {
+                                sub.onNext(1);
+                                sub.onError(e2);
+                            }
+                        }
+                    });
+                }
+            }).onBackpressureDrop(new Action1<Integer>() {
+                @Override
+                public void call(Integer t) {
+                    throw e1;
+                }
+            }).unsafeSubscribe(ts);
+            ts.assertNoValues();
+            assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
+            ts.assertNotCompleted();
+            assertEquals(Arrays.asList(e2), list);
+        } finally {
+            RxJavaHooks.setOnError(null);
+        }
+    }
+    
+    @Test
+    public void testUpstreamEmitsOnNextAfterFailureWithoutCheckingSubscription() {
+        TestSubscriber<Integer> ts = TestSubscriber.create(0);
+        final RuntimeException e = new RuntimeException();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 1) {
+                            sub.onNext(1);
+                            sub.onNext(2);
+                        }
+                    }
+                });
+            }
+        })
+        .onBackpressureDrop(new Action1<Integer>() {
+            @Override
+            public void call(Integer t) {
+                throw e;
+            }})
+        .unsafeSubscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(e);
+        ts.assertNotCompleted();
+    }
+    
+    
+    
     private static final Action1<Long> THROW_NON_FATAL = new Action1<Long>() {
         @Override
         public void call(Long n) {

From 888560edb055d297822c8e1021fe9ef224e31352 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 28 Jul 2016 16:23:38 +0200
Subject: [PATCH 132/263] 1.x: fix SingleTest generics warnings (#4254)

---
 src/test/java/rx/SingleTest.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index 375feafc7e..acc95c6ef6 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -2008,7 +2008,7 @@ public Single<Integer> call(Integer v) {
     @Test
     public void flatMapCompletableComplete() {
         final AtomicInteger atomicInteger = new AtomicInteger();
-        TestSubscriber testSubscriber = TestSubscriber.create();
+        TestSubscriber<Object> testSubscriber = TestSubscriber.create();
 
         Single.just(1).flatMapCompletable(new Func1<Integer, Completable>() {
             @Override
@@ -2030,7 +2030,7 @@ public void call() {
     @Test
     public void flatMapCompletableError() {
         final RuntimeException error = new RuntimeException("some error");
-        TestSubscriber testSubscriber = TestSubscriber.create();
+        TestSubscriber<Object> testSubscriber = TestSubscriber.create();
 
         Single.just(1).flatMapCompletable(new Func1<Integer, Completable>() {
             @Override
@@ -2044,7 +2044,7 @@ public Completable call(final Integer integer) {
 
     @Test
     public void flatMapCompletableNullCompletable() {
-        TestSubscriber testSubscriber = TestSubscriber.create();
+        TestSubscriber<Object> testSubscriber = TestSubscriber.create();
 
         Single.just(1).flatMapCompletable(new Func1<Integer, Completable>() {
             @Override
@@ -2058,7 +2058,7 @@ public Completable call(final Integer integer) {
 
     @Test
     public void flatMapCompletableException() {
-        TestSubscriber testSubscriber = TestSubscriber.create();
+        TestSubscriber<Object> testSubscriber = TestSubscriber.create();
 
         Single.just(1).flatMapCompletable(new Func1<Integer, Completable>() {
             @Override

From 2a50c2fe34d06fad199d097b9ee3352f3a5ce2f8 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Fri, 29 Jul 2016 17:24:11 +1000
Subject: [PATCH 133/263] collect - prevent multiple terminal events (#4252)

---
 .../DeferredScalarSubscriberSafe.java         |  57 ++++
 .../operators/OnSubscribeCollect.java         |   7 +-
 src/test/java/rx/ObservableTests.java         |  55 ----
 .../operators/OnSubscribeCollectTest.java     | 253 ++++++++++++++++++
 .../operators/OnSubscribeReduceTest.java      |   2 +-
 .../internal/operators/OperatorAllTest.java   |   2 +-
 .../internal/operators/OperatorAnyTest.java   |   2 +-
 7 files changed, 318 insertions(+), 60 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/DeferredScalarSubscriberSafe.java
 create mode 100644 src/test/java/rx/internal/operators/OnSubscribeCollectTest.java

diff --git a/src/main/java/rx/internal/operators/DeferredScalarSubscriberSafe.java b/src/main/java/rx/internal/operators/DeferredScalarSubscriberSafe.java
new file mode 100644
index 0000000000..3ec25c404a
--- /dev/null
+++ b/src/main/java/rx/internal/operators/DeferredScalarSubscriberSafe.java
@@ -0,0 +1,57 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.Subscriber;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Supplements {@code DeferredScalarSubscriber} with defensive behaviour that ensures no emissions
+ * occur after a terminal event. If {@code onError} is called more than once then errors after the first
+ * are reported to {@code RxJavaHooks.onError}.
+ * 
+ * @param <T> source value type
+ * @param <R> result value type
+ */
+public abstract class DeferredScalarSubscriberSafe<T, R> extends DeferredScalarSubscriber<T,R> {
+
+    protected boolean done;
+    
+    public DeferredScalarSubscriberSafe(Subscriber<? super R> actual) {
+        super(actual);
+    }
+
+    @Override
+    public void onError(Throwable ex) {
+        if (!done) {
+            done = true;
+            super.onError(ex);
+        } else {
+            RxJavaHooks.onError(ex);
+        }
+    }
+
+    @Override
+    public void onCompleted() {
+        if (done) {
+            return;
+        }
+        done = true;
+        super.onCompleted();
+    }
+    
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeCollect.java b/src/main/java/rx/internal/operators/OnSubscribeCollect.java
index 9e28ece0d7..94257e08c8 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeCollect.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeCollect.java
@@ -50,7 +50,7 @@ public void call(Subscriber<? super R> t) {
         new CollectSubscriber<T, R>(t, initialValue, collector).subscribeTo(source);
     }
     
-    static final class CollectSubscriber<T, R> extends DeferredScalarSubscriber<T, R> {
+    static final class CollectSubscriber<T, R> extends DeferredScalarSubscriberSafe<T, R> {
 
         final Action2<R, ? super T> collector;
 
@@ -63,12 +63,15 @@ public CollectSubscriber(Subscriber<? super R> actual, R initialValue, Action2<R
 
         @Override
         public void onNext(T t) {
+            if (done) {
+                return;
+            }
             try {
                 collector.call(value, t);
             } catch (Throwable ex) {
                 Exceptions.throwIfFatal(ex);
                 unsubscribe();
-                actual.onError(ex);
+                onError(ex);
             }
         }
         
diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
index 273d705fba..b3b6251778 100644
--- a/src/test/java/rx/ObservableTests.java
+++ b/src/test/java/rx/ObservableTests.java
@@ -939,62 +939,7 @@ public void testRangeWithScheduler() {
         inOrder.verifyNoMoreInteractions();
     }
 
-    @Test
-    public void testCollectToList() {
-        Observable<List<Integer>> o = Observable.just(1, 2, 3).collect(new Func0<List<Integer>>() {
-
-            @Override
-            public List<Integer> call() {
-                return new ArrayList<Integer>();
-            }
-            
-        }, new Action2<List<Integer>, Integer>() {
-
-            @Override
-            public void call(List<Integer> list, Integer v) {
-                list.add(v);
-            }
-        });
         
-        List<Integer> list =  o.toBlocking().last();
-
-        assertEquals(3, list.size());
-        assertEquals(1, list.get(0).intValue());
-        assertEquals(2, list.get(1).intValue());
-        assertEquals(3, list.get(2).intValue());
-        
-        // test multiple subscribe
-        List<Integer> list2 =  o.toBlocking().last();
-
-        assertEquals(3, list2.size());
-        assertEquals(1, list2.get(0).intValue());
-        assertEquals(2, list2.get(1).intValue());
-        assertEquals(3, list2.get(2).intValue());
-    }
-
-    @Test
-    public void testCollectToString() {
-        String value = Observable.just(1, 2, 3).collect(new Func0<StringBuilder>() {
-
-            @Override
-            public StringBuilder call() {
-                return new StringBuilder();
-            }
-            
-        }, new Action2<StringBuilder, Integer>() {
-
-            @Override
-            public void call(StringBuilder sb, Integer v) {
-                if (sb.length() > 0) {
-                    sb.append("-");
-                }
-                sb.append(v);
-            }
-        }).toBlocking().last().toString();
-
-        assertEquals("1-2-3", value);
-    }
-    
     @Test
     public void testMergeWith() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java b/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java
new file mode 100644
index 0000000000..c72be2cf7f
--- /dev/null
+++ b/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java
@@ -0,0 +1,253 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Producer;
+import rx.Subscriber;
+import rx.Observable.OnSubscribe;
+import rx.functions.Action1;
+import rx.functions.Action2;
+import rx.functions.Func0;
+import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
+
+public class OnSubscribeCollectTest {
+
+    @Test
+    public void testCollectToList() {
+        Observable<List<Integer>> o = Observable.just(1, 2, 3).collect(new Func0<List<Integer>>() {
+
+            @Override
+            public List<Integer> call() {
+                return new ArrayList<Integer>();
+            }
+            
+        }, new Action2<List<Integer>, Integer>() {
+
+            @Override
+            public void call(List<Integer> list, Integer v) {
+                list.add(v);
+            }
+        });
+        
+        List<Integer> list =  o.toBlocking().last();
+
+        assertEquals(3, list.size());
+        assertEquals(1, list.get(0).intValue());
+        assertEquals(2, list.get(1).intValue());
+        assertEquals(3, list.get(2).intValue());
+        
+        // test multiple subscribe
+        List<Integer> list2 =  o.toBlocking().last();
+
+        assertEquals(3, list2.size());
+        assertEquals(1, list2.get(0).intValue());
+        assertEquals(2, list2.get(1).intValue());
+        assertEquals(3, list2.get(2).intValue());
+    }
+
+    @Test
+    public void testCollectToString() {
+        String value = Observable.just(1, 2, 3).collect(new Func0<StringBuilder>() {
+
+            @Override
+            public StringBuilder call() {
+                return new StringBuilder();
+            }
+            
+        }, new Action2<StringBuilder, Integer>() {
+
+            @Override
+            public void call(StringBuilder sb, Integer v) {
+                if (sb.length() > 0) {
+                    sb.append("-");
+                }
+                sb.append(v);
+            }
+        }).toBlocking().last().toString();
+
+        assertEquals("1-2-3", value);
+    }
+    
+    @Test
+    public void testFactoryFailureResultsInErrorEmission() {
+        TestSubscriber<Object> ts = TestSubscriber.create();
+        final RuntimeException e = new RuntimeException();
+        Observable.just(1).collect(new Func0<List<Integer>>() {
+
+            @Override
+            public List<Integer> call() {
+                throw e;
+            }
+        }, new Action2<List<Integer>, Integer>() {
+
+            @Override
+            public void call(List<Integer> list, Integer t) {
+                list.add(t);
+            }
+        }).subscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(e);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testCollectorFailureDoesNotResultInTwoErrorEmissions() {
+        try {
+            final List<Throwable> list = new CopyOnWriteArrayList<Throwable>();
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+
+                @Override
+                public void call(Throwable t) {
+                    list.add(t);
+                }
+            });
+            final RuntimeException e1 = new RuntimeException();
+            final RuntimeException e2 = new RuntimeException();
+            TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+            Observable.create(new OnSubscribe<Integer>() {
+
+                @Override
+                public void call(final Subscriber<? super Integer> sub) {
+                    sub.setProducer(new Producer() {
+
+                        @Override
+                        public void request(long n) {
+                            if (n > 0) {
+                                sub.onNext(1);
+                                sub.onError(e2);
+                            }
+                        }
+                    });
+                }
+            }).collect(new Func0<List<Integer>>() {
+
+                @Override
+                public List<Integer> call() {
+                    return new ArrayList<Integer>();
+                }
+            }, //
+                    new Action2<List<Integer>, Integer>() {
+
+                        @Override
+                        public void call(List<Integer> t1, Integer t2) {
+                            throw e1;
+                        }
+                    }).unsafeSubscribe(ts);
+            assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
+            ts.assertNotCompleted();
+            assertEquals(Arrays.asList(e2), list);
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+
+    @Test
+    public void testCollectorFailureDoesNotResultInErrorAndCompletedEmissions() {
+        final RuntimeException e1 = new RuntimeException();
+        TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 0) {
+                            sub.onNext(1);
+                            sub.onCompleted();
+                        }
+                    }
+                });
+            }
+        }).collect(new Func0<List<Integer>>() {
+
+            @Override
+            public List<Integer> call() {
+                return new ArrayList<Integer>();
+            }
+        }, //
+                new Action2<List<Integer>, Integer>() {
+
+                    @Override
+                    public void call(List<Integer> t1, Integer t2) {
+                        throw e1;
+                    }
+                }).unsafeSubscribe(ts);
+        assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void testCollectorFailureDoesNotResultInErrorAndOnNextEmissions() {
+        final RuntimeException e1 = new RuntimeException();
+        TestSubscriber<List<Integer>> ts = TestSubscriber.create();
+        final AtomicBoolean added = new AtomicBoolean();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 0) {
+                            sub.onNext(1);
+                            sub.onNext(2);
+                        }
+                    }
+                });
+            }
+        }).collect(new Func0<List<Integer>>() {
+
+            @Override
+            public List<Integer> call() {
+                return new ArrayList<Integer>();
+            }
+        }, //
+                new Action2<List<Integer>, Integer>() {
+                    boolean once = true;
+                    @Override
+                    public void call(List<Integer> list, Integer t) {
+                        if (once) {
+                            once = false;
+                            throw e1;
+                        } else {
+                            added.set(true);
+                        }
+                    }
+                }).unsafeSubscribe(ts);
+        assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
+        ts.assertNoValues();
+        ts.assertNotCompleted();
+        assertFalse(added.get());
+    }
+    
+}
diff --git a/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java b/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
index b09f92c158..7b0f55f6f3 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
@@ -255,7 +255,7 @@ public Integer call(Integer a, Integer b) {
             assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
             assertEquals(Arrays.asList(e2), list);
         } finally {
-            RxJavaHooks.setOnError(null);
+            RxJavaHooks.reset();
         }
     }
 
diff --git a/src/test/java/rx/internal/operators/OperatorAllTest.java b/src/test/java/rx/internal/operators/OperatorAllTest.java
index 4bac172aae..0a22203d18 100644
--- a/src/test/java/rx/internal/operators/OperatorAllTest.java
+++ b/src/test/java/rx/internal/operators/OperatorAllTest.java
@@ -289,7 +289,7 @@ public Boolean call(Integer t) {
             assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
             assertEquals(Arrays.asList(e2), list);
         } finally {
-            RxJavaHooks.setOnError(null);
+            RxJavaHooks.reset();
         }
     }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorAnyTest.java b/src/test/java/rx/internal/operators/OperatorAnyTest.java
index a9830c8a32..85f1cd3c93 100644
--- a/src/test/java/rx/internal/operators/OperatorAnyTest.java
+++ b/src/test/java/rx/internal/operators/OperatorAnyTest.java
@@ -382,7 +382,7 @@ public Boolean call(Integer t) {
             assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
             assertEquals(Arrays.asList(e2), list);
         } finally {
-            RxJavaHooks.setOnError(null);
+            RxJavaHooks.reset();
         }
     }
 }

From 4ce0d55a9bce70b81a61a5ecd3c7a03753aca2c4 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 29 Jul 2016 09:39:10 +0200
Subject: [PATCH 134/263] Increase git depth to satisfy version inference

---
 .travis.yml                                                     | 2 +-
 src/test/java/rx/internal/operators/OnSubscribeCollectTest.java | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 4ecbec4dfa..f07cf8d5e4 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,7 +5,7 @@ sudo: false
 # as per http://blog.travis-ci.com/2014-12-17-faster-builds-with-container-based-infrastructure/
 
 git:
-  depth: 20
+  depth: 50
 
 # prevent travis running gradle assemble; let the build script do it anyway
 install: true
diff --git a/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java b/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java
index c72be2cf7f..f57e493223 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java
@@ -24,7 +24,6 @@
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import org.junit.Assert;
 import org.junit.Test;
 
 import rx.Observable;

From 0577b4c49f744ae6a49505ffeb8937e6a0730f3b Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Fri, 29 Jul 2016 17:57:04 +1000
Subject: [PATCH 135/263] Fix javadoc on RxJavaHooks.setOnError (#4257)

---
 src/main/java/rx/plugins/RxJavaHooks.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index f32f3d6d0d..f528f66f76 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -580,7 +580,7 @@ public static <T, R> Completable.CompletableOperator onCompletableLift(Completab
      * <p>
      * This operation is threadsafe.
      * <p>
-     * Calling with a {@code null} parameter restores the default behavior:
+     * Calling with a {@code null} parameter has the effect that
      * errors are routed to the current thread's {@link UncaughtExceptionHandler}.
      * @param onError the action that will receive undeliverable Throwables
      */

From 969d94cdd382e6c08f6025413716fc89cc5632ae Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Sat, 30 Jul 2016 16:57:04 +1000
Subject: [PATCH 136/263] toMap - prevent multiple terminal events and support
 backpressures (#4251)

---
 src/main/java/rx/Observable.java              |   6 +-
 ...eratorToMap.java => OnSubscribeToMap.java} | 134 ++++++++--------
 ...MapTest.java => OnSubscribeToMapTest.java} | 148 +++++++++++++++++-
 3 files changed, 210 insertions(+), 78 deletions(-)
 rename src/main/java/rx/internal/operators/{OperatorToMap.java => OnSubscribeToMap.java} (52%)
 rename src/test/java/rx/internal/operators/{OperatorToMapTest.java => OnSubscribeToMapTest.java} (66%)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 1aeed4c6a9..d2f187bef3 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -11158,7 +11158,7 @@ public final Observable<List<T>> toList() {
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySelector) {
-        return lift(new OperatorToMap<T, K, T>(keySelector, UtilityFunctions.<T>identity()));
+        return create(new OnSubscribeToMap<T, K, T>(this, keySelector, UtilityFunctions.<T>identity()));
     }
 
     /**
@@ -11188,7 +11188,7 @@ public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySe
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
-        return lift(new OperatorToMap<T, K, V>(keySelector, valueSelector));
+        return create(new OnSubscribeToMap<T, K, V>(this, keySelector, valueSelector));
     }
 
     /**
@@ -11217,7 +11217,7 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, V>> mapFactory) {
-        return lift(new OperatorToMap<T, K, V>(keySelector, valueSelector, mapFactory));
+        return create(new OnSubscribeToMap<T, K, V>(this, keySelector, valueSelector, mapFactory));
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/OperatorToMap.java b/src/main/java/rx/internal/operators/OnSubscribeToMap.java
similarity index 52%
rename from src/main/java/rx/internal/operators/OperatorToMap.java
rename to src/main/java/rx/internal/operators/OnSubscribeToMap.java
index c346d7476b..a15014e1f3 100644
--- a/src/main/java/rx/internal/operators/OperatorToMap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeToMap.java
@@ -16,13 +16,15 @@
 
 package rx.internal.operators;
 
-import java.util.*;
+import java.util.HashMap;
+import java.util.Map;
 
-import rx.Observable.Operator;
+import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Subscriber;
 import rx.exceptions.Exceptions;
-import rx.functions.*;
-import rx.observers.Subscribers;
+import rx.functions.Func0;
+import rx.functions.Func1;
 
 /**
  * Maps the elements of the source observable into a java.util.Map instance and
@@ -33,35 +35,25 @@
  * @param <K> the map-key type
  * @param <V> the map-value type
  */
-public final class OperatorToMap<T, K, V> implements Operator<Map<K, V>, T> {
+public final class OnSubscribeToMap<T, K, V> implements OnSubscribe<Map<K, V>>, Func0<Map<K, V>> {
+
+    final Observable<T> source;
 
     final Func1<? super T, ? extends K> keySelector;
 
     final Func1<? super T, ? extends V> valueSelector;
 
-    private final Func0<? extends Map<K, V>> mapFactory;
-
-    /**
-     * The default map factory.
-     * @param <K> the key type
-     * @param <V> the value type
-     */
-    public static final class DefaultToMapFactory<K, V> implements Func0<Map<K, V>> {
-        @Override
-        public Map<K, V> call() {
-            return new HashMap<K, V>();
-        }
-    }
+    final Func0<? extends Map<K, V>> mapFactory;
 
     /**
      * ToMap with key selector, value selector and default HashMap factory.
      * @param keySelector the function extracting the map-key from the main value
      * @param valueSelector the function extracting the map-value from the main value
      */
-    public OperatorToMap(
+    public OnSubscribeToMap(Observable<T> source,
             Func1<? super T, ? extends K> keySelector,
             Func1<? super T, ? extends V> valueSelector) {
-        this(keySelector, valueSelector, new DefaultToMapFactory<K, V>());
+        this(source, keySelector, valueSelector, null);
     }
 
 
@@ -71,70 +63,72 @@ public OperatorToMap(
      * @param valueSelector the function extracting the map-value from the main value
      * @param mapFactory function that returns a Map instance to store keys and values into
      */
-    public OperatorToMap(
+    public OnSubscribeToMap(Observable<T> source,
             Func1<? super T, ? extends K> keySelector,
             Func1<? super T, ? extends V> valueSelector,
             Func0<? extends Map<K, V>> mapFactory) {
+        this.source = source;
         this.keySelector = keySelector;
         this.valueSelector = valueSelector;
-        this.mapFactory = mapFactory;
-
+        if (mapFactory == null) {
+            this.mapFactory = this;
+        } else {
+            this.mapFactory = mapFactory;
+        }
     }
 
     @Override
-    public Subscriber<? super T> call(final Subscriber<? super Map<K, V>> subscriber) {
-        
-        Map<K, V> localMap;
-        
+    public Map<K, V> call() {
+        return new HashMap<K, V>();
+    }
+    
+    @Override
+    public void call(final Subscriber<? super Map<K, V>> subscriber) {
+        Map<K, V> map;
         try {
-            localMap = mapFactory.call();
+            map = mapFactory.call();
         } catch (Throwable ex) {
             Exceptions.throwOrReport(ex, subscriber);
-            Subscriber<? super T> parent = Subscribers.empty();
-            parent.unsubscribe();
-            return parent;
+            return;
+        }
+        new ToMapSubscriber<T, K, V>(subscriber, map, keySelector, valueSelector)
+            .subscribeTo(source);;    
+    }
+    
+    static final class ToMapSubscriber<T, K, V> extends DeferredScalarSubscriberSafe<T, Map<K,V>> {
+
+        final Func1<? super T, ? extends K> keySelector;
+        final Func1<? super T, ? extends V> valueSelector;
+
+        ToMapSubscriber(Subscriber<? super Map<K,V>> actual, Map<K,V> map, Func1<? super T, ? extends K> keySelector,
+                Func1<? super T, ? extends V> valueSelector) {
+            super(actual);
+            this.value = map;
+            this.hasValue = true;
+            this.keySelector = keySelector;
+            this.valueSelector = valueSelector;
         }
-        
-        final Map<K, V> fLocalMap = localMap;
-        
-        return new Subscriber<T>(subscriber) {
-
-            private Map<K, V> map = fLocalMap;
-
-            @Override
-            public void onStart() {
-                request(Long.MAX_VALUE);
-            }
-            
-            @Override
-            public void onNext(T v) {
-                K key;
-                V value;
-
-                try {
-                    key = keySelector.call(v);
-                    value = valueSelector.call(v);
-                } catch (Throwable ex) {
-                    Exceptions.throwOrReport(ex, subscriber);
-                    return;
-                }
-                
-                map.put(key, value);
-            }
 
-            @Override
-            public void onError(Throwable e) {
-                map = null;
-                subscriber.onError(e);
+        @Override
+        public void onStart() {
+            request(Long.MAX_VALUE);
+        }
+        
+        @Override
+        public void onNext(T t) {
+            if (done) {
+                return;
             }
-
-            @Override
-            public void onCompleted() {
-                Map<K, V> map0 = map;
-                map = null;
-                subscriber.onNext(map0);
-                subscriber.onCompleted();
+            try {
+                K key = keySelector.call(t);
+                V val = valueSelector.call(t);
+                value.put(key, val);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                onError(ex);
             }
-        };
+        }
     }
+    
 }
diff --git a/src/test/java/rx/internal/operators/OperatorToMapTest.java b/src/test/java/rx/internal/operators/OnSubscribeToMapTest.java
similarity index 66%
rename from src/test/java/rx/internal/operators/OperatorToMapTest.java
rename to src/test/java/rx/internal/operators/OnSubscribeToMapTest.java
index 466cff0df8..0cdba86951 100644
--- a/src/test/java/rx/internal/operators/OperatorToMapTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToMapTest.java
@@ -15,22 +15,37 @@
  */
 package rx.internal.operators;
 
+import static org.junit.Assert.assertEquals;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.verify;
 
-import java.util.*;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
 
-import org.junit.*;
-import org.mockito.*;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
+import rx.Producer;
+import rx.Subscriber;
 import rx.exceptions.TestException;
-import rx.functions.*;
+import rx.functions.Action1;
+import rx.functions.Func0;
+import rx.functions.Func1;
 import rx.internal.util.UtilityFunctions;
 import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
 
-public class OperatorToMapTest {
+public class OnSubscribeToMapTest {
     @Mock
     Observer<Object> objectObserver;
 
@@ -281,4 +296,127 @@ public Map<Integer, Integer> call() {
         ts.assertNoValues();
         ts.assertNotCompleted();
     }
+    
+    @Test
+    public void testFactoryFailureDoesNotAllowErrorAndCompletedEmissions() {
+        TestSubscriber<Map<Integer, Integer>> ts = TestSubscriber.create(0);
+        final RuntimeException e = new RuntimeException();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 1) {
+                            sub.onNext(1);
+                            sub.onCompleted();
+                        }
+                    }
+                });
+            }
+        }).toMap(new Func1<Integer,Integer>() {
+
+            @Override
+            public Integer call(Integer t) {
+                throw e;
+            }
+        }).unsafeSubscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(e);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testFactoryFailureDoesNotAllowTwoErrorEmissions() {
+        try {
+            final List<Throwable> list = new CopyOnWriteArrayList<Throwable>();
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+
+                @Override
+                public void call(Throwable t) {
+                    list.add(t);
+                }
+            });
+            TestSubscriber<Map<Integer, Integer>> ts = TestSubscriber.create(0);
+            final RuntimeException e1 = new RuntimeException();
+            final RuntimeException e2 = new RuntimeException();
+            Observable.create(new OnSubscribe<Integer>() {
+
+                @Override
+                public void call(final Subscriber<? super Integer> sub) {
+                    sub.setProducer(new Producer() {
+
+                        @Override
+                        public void request(long n) {
+                            if (n > 1) {
+                                sub.onNext(1);
+                                sub.onError(e2);
+                            }
+                        }
+                    });
+                }
+            }).toMap(new Func1<Integer, Integer>() {
+
+                @Override
+                public Integer call(Integer t) {
+                    throw e1;
+                }
+            }).unsafeSubscribe(ts);
+            ts.assertNoValues();
+            assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
+            assertEquals(Arrays.asList(e2), list);
+            ts.assertNotCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+    
+    @Test
+    public void testFactoryFailureDoesNotAllowErrorThenOnNextEmissions() {
+        TestSubscriber<Map<Integer, Integer>> ts = TestSubscriber.create(0);
+        final RuntimeException e = new RuntimeException();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 1) {
+                            sub.onNext(1);
+                            sub.onNext(2);
+                        }
+                    }
+                });
+            }
+        }).toMap(new Func1<Integer,Integer>() {
+
+            @Override
+            public Integer call(Integer t) {
+                throw e;
+            }
+        }).unsafeSubscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(e);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testBackpressure() {
+        TestSubscriber<Object> ts = TestSubscriber.create(0);
+        Observable
+            .just("a", "bb", "ccc", "dddd")
+            .toMap(lengthFunc)
+            .subscribe(ts);
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+        ts.assertNoValues();
+        ts.requestMore(1);
+        ts.assertValueCount(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
 }

From 3639e731b0b749ba864674d6971a00ee4a812496 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Sun, 31 Jul 2016 20:51:57 +1000
Subject: [PATCH 137/263] doOnEach - reduce allocations, report to RxJavaHooks,
 use OnSubscribe (#4262)

---
 src/main/java/rx/Observable.java              |  21 ++-
 src/main/java/rx/Single.java                  |   4 +-
 .../operators/OnSubscribeDoOnEach.java        | 104 ++++++++++++
 .../internal/operators/OperatorDoOnEach.java  |  90 -----------
 .../java/rx/internal/util/ActionObserver.java |  51 ++++++
 ...Test.java => OnSubscribeDoOnEachTest.java} | 149 +++++++++++++++++-
 .../operators/OnSubscribeReduceTest.java      |   1 -
 7 files changed, 315 insertions(+), 105 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeDoOnEach.java
 delete mode 100644 src/main/java/rx/internal/operators/OperatorDoOnEach.java
 create mode 100644 src/main/java/rx/internal/util/ActionObserver.java
 rename src/test/java/rx/internal/operators/{OperatorDoOnEachTest.java => OnSubscribeDoOnEachTest.java} (62%)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index d2f187bef3..3f31491b08 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -5507,9 +5507,9 @@ public final Observable<T> distinctUntilChanged(Func2<? super T, ? super T, Bool
     public final Observable<T> doOnCompleted(final Action0 onCompleted) {
         Action1<T> onNext = Actions.empty();
         Action1<Throwable> onError = Actions.empty();
-        Observer<T> observer = new ActionSubscriber<T>(onNext, onError, onCompleted);
+        Observer<T> observer = new ActionObserver<T>(onNext, onError, onCompleted);
 
-        return lift(new OperatorDoOnEach<T>(observer));
+        return create(new OnSubscribeDoOnEach<T>(this, observer));
     }
 
     /**
@@ -5531,8 +5531,7 @@ public final Observable<T> doOnCompleted(final Action0 onCompleted) {
      */
     public final Observable<T> doOnEach(final Action1<Notification<? super T>> onNotification) {
         Observer<T> observer = new ActionNotificationObserver<T>(onNotification);
-
-        return lift(new OperatorDoOnEach<T>(observer));
+        return create(new OnSubscribeDoOnEach<T>(this, observer));
     }
 
     /**
@@ -5559,7 +5558,7 @@ public final Observable<T> doOnEach(final Action1<Notification<? super T>> onNot
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
      */
     public final Observable<T> doOnEach(Observer<? super T> observer) {
-        return lift(new OperatorDoOnEach<T>(observer));
+        return create(new OnSubscribeDoOnEach<T>(this, observer));
     }
 
     /**
@@ -5585,9 +5584,9 @@ public final Observable<T> doOnEach(Observer<? super T> observer) {
     public final Observable<T> doOnError(final Action1<Throwable> onError) {
         Action1<T> onNext = Actions.empty();
         Action0 onCompleted = Actions.empty();
-        Observer<T> observer = new ActionSubscriber<T>(onNext, onError, onCompleted);
+        Observer<T> observer = new ActionObserver<T>(onNext, onError, onCompleted);
 
-        return lift(new OperatorDoOnEach<T>(observer));
+        return create(new OnSubscribeDoOnEach<T>(this, observer));
     }
 
     /**
@@ -5610,9 +5609,9 @@ public final Observable<T> doOnError(final Action1<Throwable> onError) {
     public final Observable<T> doOnNext(final Action1<? super T> onNext) {
         Action1<Throwable> onError = Actions.empty();
         Action0 onCompleted = Actions.empty();
-        Observer<T> observer = new ActionSubscriber<T>(onNext, onError, onCompleted);
+        Observer<T> observer = new ActionObserver<T>(onNext, onError, onCompleted);
 
-        return lift(new OperatorDoOnEach<T>(observer));
+        return create(new OnSubscribeDoOnEach<T>(this, observer));
     }
 
     /**
@@ -5693,9 +5692,9 @@ public final Observable<T> doOnTerminate(final Action0 onTerminate) {
         Action1<T> onNext = Actions.empty();
         Action1<Throwable> onError = Actions.toAction1(onTerminate);
         
-        Observer<T> observer = new ActionSubscriber<T>(onNext, onError, onTerminate);
+        Observer<T> observer = new ActionObserver<T>(onNext, onError, onTerminate);
 
-        return lift(new OperatorDoOnEach<T>(observer));
+        return create(new OnSubscribeDoOnEach<T>(this, observer));
     }
     
     /**
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index c1a89043a6..198dba876c 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -2413,7 +2413,7 @@ public void onNext(T t) {
             }
         };
 
-        return lift(new OperatorDoOnEach<T>(observer));
+        return Observable.create(new OnSubscribeDoOnEach<T>(this.toObservable(), observer)).toSingle();
     }
     
     /**
@@ -2449,7 +2449,7 @@ public void onNext(T t) {
             }
         };
 
-        return lift(new OperatorDoOnEach<T>(observer));
+        return Observable.create(new OnSubscribeDoOnEach<T>(this.toObservable(), observer)).toSingle();
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDoOnEach.java b/src/main/java/rx/internal/operators/OnSubscribeDoOnEach.java
new file mode 100644
index 0000000000..34694ed311
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeDoOnEach.java
@@ -0,0 +1,104 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import java.util.Arrays;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.exceptions.*;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Calls specified actions for each notification.
+ * 
+ * @param <T> the value type
+ */
+public class OnSubscribeDoOnEach<T> implements OnSubscribe<T> {
+    private final Observer<? super T> doOnEachObserver;
+    private final Observable<T> source;
+
+    public OnSubscribeDoOnEach(Observable<T> source, Observer<? super T> doOnEachObserver) {
+        this.source = source;
+        this.doOnEachObserver = doOnEachObserver;
+    }
+
+    @Override
+    public void call(final Subscriber<? super T> subscriber) {
+        source.unsafeSubscribe(new DoOnEachSubscriber<T>(subscriber, doOnEachObserver));
+    }
+    
+    private static final class DoOnEachSubscriber<T> extends Subscriber<T> {
+
+        private final Subscriber<? super T> subscriber;
+        private final Observer<? super T> doOnEachObserver;
+        
+        private boolean done;
+
+        DoOnEachSubscriber(Subscriber<? super T> subscriber, Observer<? super T> doOnEachObserver) {
+            super(subscriber);
+            this.subscriber = subscriber;
+            this.doOnEachObserver = doOnEachObserver;
+        }
+
+        @Override
+        public void onCompleted() {
+            if (done) {
+                return;
+            }
+            try {
+                doOnEachObserver.onCompleted();
+            } catch (Throwable e) {
+                Exceptions.throwOrReport(e, this);
+                return;
+            }
+            // Set `done` here so that the error in `doOnEachObserver.onCompleted()` can be noticed by observer
+            done = true;
+            subscriber.onCompleted();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            if (done) {
+                RxJavaHooks.onError(e);
+                return;
+            }
+            done = true;
+            try {
+                doOnEachObserver.onError(e);
+            } catch (Throwable e2) {
+                Exceptions.throwIfFatal(e2);
+                subscriber.onError(new CompositeException(Arrays.asList(e, e2)));
+                return;
+            }
+            subscriber.onError(e);
+        }
+
+        @Override
+        public void onNext(T value) {
+            if (done) {
+                return;
+            }
+            try {
+                doOnEachObserver.onNext(value);
+            } catch (Throwable e) {
+                Exceptions.throwOrReport(e, this, value);
+                return;
+            }
+            subscriber.onNext(value);
+        }        
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/rx/internal/operators/OperatorDoOnEach.java b/src/main/java/rx/internal/operators/OperatorDoOnEach.java
deleted file mode 100644
index 0e3034a425..0000000000
--- a/src/main/java/rx/internal/operators/OperatorDoOnEach.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- * 
- * 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 rx.internal.operators;
-
-import java.util.Arrays;
-
-import rx.*;
-import rx.Observable.Operator;
-import rx.exceptions.*;
-
-/**
- * Converts the elements of an observable sequence to the specified type.
- * @param <T> the value type
- */
-public class OperatorDoOnEach<T> implements Operator<T, T> {
-    final Observer<? super T> doOnEachObserver;
-
-    public OperatorDoOnEach(Observer<? super T> doOnEachObserver) {
-        this.doOnEachObserver = doOnEachObserver;
-    }
-
-    @Override
-    public Subscriber<? super T> call(final Subscriber<? super T> observer) {
-        return new Subscriber<T>(observer) {
-
-            private boolean done;
-
-            @Override
-            public void onCompleted() {
-                if (done) {
-                    return;
-                }
-                try {
-                    doOnEachObserver.onCompleted();
-                } catch (Throwable e) {
-                    Exceptions.throwOrReport(e, this);
-                    return;
-                }
-                // Set `done` here so that the error in `doOnEachObserver.onCompleted()` can be noticed by observer
-                done = true;
-                observer.onCompleted();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                // need to throwIfFatal since we swallow errors after terminated
-                Exceptions.throwIfFatal(e);
-                if (done) {
-                    return;
-                }
-                done = true;
-                try {
-                    doOnEachObserver.onError(e);
-                } catch (Throwable e2) {
-                    Exceptions.throwIfFatal(e2);
-                    observer.onError(new CompositeException(Arrays.asList(e, e2)));
-                    return;
-                }
-                observer.onError(e);
-            }
-
-            @Override
-            public void onNext(T value) {
-                if (done) {
-                    return;
-                }
-                try {
-                    doOnEachObserver.onNext(value);
-                } catch (Throwable e) {
-                    Exceptions.throwOrReport(e, this, value);
-                    return;
-                }
-                observer.onNext(value);
-            }
-        };
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/rx/internal/util/ActionObserver.java b/src/main/java/rx/internal/util/ActionObserver.java
new file mode 100644
index 0000000000..c7a17791bd
--- /dev/null
+++ b/src/main/java/rx/internal/util/ActionObserver.java
@@ -0,0 +1,51 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.util;
+
+import rx.Observer;
+import rx.functions.*;
+
+/**
+ * An Observer that forwards the onXXX method calls to callbacks.
+ * @param <T> the value type
+ */
+public final class ActionObserver<T> implements Observer<T> {
+
+    final Action1<? super T> onNext;
+    final Action1<Throwable> onError;
+    final Action0 onCompleted;
+
+    public ActionObserver(Action1<? super T> onNext, Action1<Throwable> onError, Action0 onCompleted) {
+        this.onNext = onNext;
+        this.onError = onError;
+        this.onCompleted = onCompleted;
+    }
+
+    @Override
+    public void onNext(T t) {
+        onNext.call(t);
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        onError.call(e);
+    }
+
+    @Override
+    public void onCompleted() {
+        onCompleted.call();
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/rx/internal/operators/OperatorDoOnEachTest.java b/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
similarity index 62%
rename from src/test/java/rx/internal/operators/OperatorDoOnEachTest.java
rename to src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
index 3c4cf9f9bb..f9997c3827 100644
--- a/src/test/java/rx/internal/operators/OperatorDoOnEachTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
@@ -19,18 +19,23 @@
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.*;
 
+import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.*;
 import org.mockito.*;
 
 import rx.*;
+import rx.Observable.OnSubscribe;
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
 
-public class OperatorDoOnEachTest {
+public class OnSubscribeDoOnEachTest {
 
     @Mock
     Observer<String> subscribedObserver;
@@ -219,4 +224,146 @@ public void call(Throwable e) {
         assertTrue(exceptions.get(0) instanceof TestException);
         assertTrue(exceptions.get(1) instanceof TestException);
     }
+    
+    @Test
+    public void testIfOnNextActionFailsEmitsErrorAndDoesNotFollowWithCompleted() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        final RuntimeException e1 = new RuntimeException();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> subscriber) {
+                subscriber.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 0) {
+                            subscriber.onNext(1);
+                            subscriber.onCompleted();
+                        }
+                    }});
+            }})
+            .doOnNext(new Action1<Integer>() {
+
+                @Override
+                public void call(Integer t) {
+                    throw e1;
+                }})
+            .unsafeSubscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(e1);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testIfOnNextActionFailsEmitsErrorAndDoesNotFollowWithOnNext() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        final RuntimeException e1 = new RuntimeException();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> subscriber) {
+                subscriber.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 2) {
+                            subscriber.onNext(1);
+                            subscriber.onNext(2);
+                        }
+                    }});
+            }})
+            .doOnNext(new Action1<Integer>() {
+                
+                @Override
+                public void call(Integer t) {
+                    throw e1;
+                }})
+            .unsafeSubscribe(ts);
+        ts.assertNoValues();
+        assertEquals(1, ts.getOnErrorEvents().size());
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testIfOnNextActionFailsEmitsErrorAndReportsMoreErrorsToRxJavaHooksNotDownstream() {
+        try {
+            final List<Throwable> list= new CopyOnWriteArrayList<Throwable>();
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+
+                @Override
+                public void call(Throwable e) {
+                     list.add(e);  
+                }});
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+            final RuntimeException e1 = new RuntimeException();
+            final RuntimeException e2 = new RuntimeException();
+            Observable.create(new OnSubscribe<Integer>() {
+
+                @Override
+                public void call(final Subscriber<? super Integer> subscriber) {
+                    subscriber.setProducer(new Producer() {
+
+                        @Override
+                        public void request(long n) {
+                            if (n > 2) {
+                                subscriber.onNext(1);
+                                subscriber.onError(e2);
+                            }
+                        }
+                    });
+                }
+            }).doOnNext(new Action1<Integer>() {
+
+                @Override
+                public void call(Integer t) {
+                    throw e1;
+                }
+            }).unsafeSubscribe(ts);
+            ts.assertNoValues();
+            assertEquals(1, ts.getOnErrorEvents().size());
+            ts.assertNotCompleted();
+            assertEquals(Arrays.asList(e2), list);
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+    
+    @Test
+    public void testIfCompleteActionFailsEmitsError() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        final RuntimeException e1 = new RuntimeException();
+        Observable.<Integer>empty()
+            .doOnCompleted(new Action0() {
+
+                @Override
+                public void call() {
+                    throw e1;
+                }})
+            .unsafeSubscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(e1);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testUnsubscribe() {
+        TestSubscriber<Object> ts = TestSubscriber.create(0);
+        final AtomicBoolean unsub = new AtomicBoolean();
+        Observable.just(1,2,3,4)
+           .doOnUnsubscribe(new Action0() {
+
+            @Override
+            public void call() {
+                unsub.set(true);
+            }})
+           .doOnNext(Actions.empty())
+           .subscribe(ts);
+        ts.requestMore(1);
+        ts.unsubscribe();
+        ts.assertNotCompleted();
+        ts.assertValueCount(1);
+        assertTrue(unsub.get());
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java b/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
index 7b0f55f6f3..eddc465189 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
@@ -273,5 +273,4 @@ public Integer call(Integer a, Integer b) {
         ts.assertError(NoSuchElementException.class);
     }
 
-
 }

From f2591cb032ab92596a277f2a2095cded09818425 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Mon, 1 Aug 2016 15:15:42 +1000
Subject: [PATCH 138/263] remove unnecessary map transformation in
 sequenceEquals operator (#4265)

---
 .../rx/internal/operators/OperatorSequenceEqual.java   | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
index a3fa333035..4c15c06672 100644
--- a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
+++ b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
@@ -35,15 +35,7 @@ private OperatorSequenceEqual() {
     }
 
     static <T> Observable<Object> materializeLite(Observable<T> source) {
-        return concat(
-                source.map(new Func1<T, Object>() {
-
-                    @Override
-                    public Object call(T t1) {
-                        return t1;
-                    }
-
-                }), just(LOCAL_ONCOMPLETED));
+        return concat(source, just(LOCAL_ONCOMPLETED));
     }
 
     /**

From c95c6507e542a3082868c44c0c9ccc5f287183d6 Mon Sep 17 00:00:00 2001
From: Jake Wharton <jakewharton@gmail.com>
Date: Mon, 1 Aug 2016 16:20:22 -0400
Subject: [PATCH 139/263] Remove needless static field for initialization.
 (#4269)

---
 src/main/java/rx/internal/util/RxRingBuffer.java | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/internal/util/RxRingBuffer.java b/src/main/java/rx/internal/util/RxRingBuffer.java
index b2104f811d..1cd9e3df0d 100644
--- a/src/main/java/rx/internal/util/RxRingBuffer.java
+++ b/src/main/java/rx/internal/util/RxRingBuffer.java
@@ -241,8 +241,9 @@ public class RxRingBuffer implements Subscription {
      * r.o.OperatorObserveOnPerf.observeOnNewThread     1000000  thrpt         5        1.173        0.100    ops/s
      * } </pre>
      */
-    static int defaultSize = 128;
     static {
+        int defaultSize = 128;
+
         // lower default for Android (https://github.com/ReactiveX/RxJava/issues/1820)
         if (PlatformDependent.isAndroid()) {
             defaultSize = 16;
@@ -257,8 +258,10 @@ public class RxRingBuffer implements Subscription {
                 System.err.println("Failed to set 'rx.buffer.size' with value " + sizeFromProperty + " => " + e.getMessage()); // NOPMD 
             }
         }
+
+        SIZE = defaultSize;
     }
-    public static final int SIZE = defaultSize;
+    public static final int SIZE;
 
     /* Public so Schedulers can manage the lifecycle of the inner worker. */
     public static final ObjectPool<Queue<Object>> SPSC_POOL = new ObjectPool<Queue<Object>>() {

From 515d7ce3ec97161761077333690911a92320183b Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Tue, 2 Aug 2016 17:29:15 +1000
Subject: [PATCH 140/263] toMultimap - prevent post-terminal-emissions (#4270)

---
 src/main/java/rx/Observable.java              |   8 +-
 .../operators/OnSubscribeToMultimap.java      | 204 ++++++++++++++++++
 .../operators/OperatorToMultimap.java         | 187 ----------------
 ...st.java => OnSubscribeToMultimapTest.java} | 160 +++++++++++++-
 4 files changed, 362 insertions(+), 197 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
 delete mode 100644 src/main/java/rx/internal/operators/OperatorToMultimap.java
 rename src/test/java/rx/internal/operators/{OperatorToMultimapTest.java => OnSubscribeToMultimapTest.java} (70%)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 3f31491b08..9967a48eab 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -11239,7 +11239,7 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ? extends K> keySelector) {
-        return lift(new OperatorToMultimap<T, K, T>(keySelector, UtilityFunctions.<T>identity()));
+        return create(new OnSubscribeToMultimap<T, K, T>(this, keySelector, UtilityFunctions.<T>identity()));
     }
 
     /**
@@ -11267,7 +11267,7 @@ public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ?
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
-        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector));
+        return create(new OnSubscribeToMultimap<T, K, V>(this, keySelector, valueSelector));
     }
 
     /**
@@ -11297,7 +11297,7 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, Collection<V>>> mapFactory) {
-        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector, mapFactory));
+        return create(new OnSubscribeToMultimap<T, K, V>(this, keySelector, valueSelector, mapFactory));
     }
 
     /**
@@ -11329,7 +11329,7 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, Collection<V>>> mapFactory, Func1<? super K, ? extends Collection<V>> collectionFactory) {
-        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector, mapFactory, collectionFactory));
+        return create(new OnSubscribeToMultimap<T, K, V>(this, keySelector, valueSelector, mapFactory, collectionFactory));
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java b/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
new file mode 100644
index 0000000000..04db4b4f02
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
@@ -0,0 +1,204 @@
+/**
+ * Copyright one 2014 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.exceptions.Exceptions;
+import rx.functions.Func0;
+import rx.functions.Func1;
+
+/**
+ * Maps the elements of the source observable into a multimap
+ * (Map&lt;K, Collection&lt;V>>) where each
+ * key entry has a collection of the source's values.
+ *
+ * @see <a href="https://github.com/ReactiveX/RxJava/issues/97">Issue #97</a>
+ * @param <T> the value type of the input
+ * @param <K> the multimap-key type
+ * @param <V> the multimap-value type
+ */
+public final class OnSubscribeToMultimap<T, K, V> implements OnSubscribe<Map<K, Collection<V>>>, Func0<Map<K, Collection<V>>> {
+
+    private final Func1<? super T, ? extends K> keySelector;
+    private final Func1<? super T, ? extends V> valueSelector;
+    private final Func0<? extends Map<K, Collection<V>>> mapFactory;
+    private final Func1<? super K, ? extends Collection<V>> collectionFactory;
+    private final Observable<T> source;
+
+    /**
+     * ToMultimap with key selector, custom value selector,
+     * default HashMap factory and default ArrayList collection factory.
+     * @param keySelector the function extracting the map-key from the main value
+     * @param valueSelector the function extracting the map-value from the main value
+     */
+    public OnSubscribeToMultimap(
+            Observable<T> source,
+            Func1<? super T, ? extends K> keySelector,
+            Func1<? super T, ? extends V> valueSelector) {
+        this(source, keySelector, valueSelector,
+                null,
+                DefaultMultimapCollectionFactory.<K, V>instance());
+    }
+
+    /**
+     * ToMultimap with key selector, custom value selector,
+     * custom Map factory and default ArrayList collection factory.
+     * @param the observable source
+     * @param keySelector the function extracting the map-key from the main value
+     * @param valueSelector the function extracting the map-value from the main value
+     * @param mapFactory function that returns a Map instance to store keys and values into
+     */
+    public OnSubscribeToMultimap(
+            Observable<T> source, 
+            Func1<? super T, ? extends K> keySelector,
+            Func1<? super T, ? extends V> valueSelector,
+            Func0<? extends Map<K, Collection<V>>> mapFactory) {
+        this(source, keySelector, valueSelector,
+                mapFactory,
+                DefaultMultimapCollectionFactory.<K, V>instance());
+    }
+
+    /**
+     * ToMultimap with key selector, custom value selector,
+     * custom Map factory and custom collection factory.
+     * @param source the observable source
+     * @param keySelector the function extracting the map-key from the main value
+     * @param valueSelector the function extracting the map-value from the main value
+     * @param mapFactory function that returns a Map instance to store keys and values into
+     * @param collectionFactory function that returns a Collection for a particular key to store values into
+     */
+    public OnSubscribeToMultimap(
+            Observable<T> source, 
+            Func1<? super T, ? extends K> keySelector,
+            Func1<? super T, ? extends V> valueSelector,
+            Func0<? extends Map<K, Collection<V>>> mapFactory,
+            Func1<? super K, ? extends Collection<V>> collectionFactory) {
+        this.source = source;
+        this.keySelector = keySelector;
+        this.valueSelector = valueSelector;
+        if (mapFactory == null) {
+            this.mapFactory = this;
+        } else {
+            this.mapFactory = mapFactory;
+        }
+        this.collectionFactory = collectionFactory;
+    }
+
+    // default map factory
+    @Override
+    public Map<K, Collection<V>> call() {
+        return new HashMap<K, Collection<V>>();
+    }
+    
+    @Override
+    public void call(final Subscriber<? super Map<K, Collection<V>>> subscriber) {
+        
+        Map<K, Collection<V>> map;
+        try {
+            map = mapFactory.call();
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            subscriber.onError(ex);
+            return;
+        }
+        new ToMultimapSubscriber<T, K, V>(
+                subscriber, map, keySelector, valueSelector, collectionFactory)
+            .subscribeTo(source);
+    }
+    
+    private static final class ToMultimapSubscriber<T, K, V> 
+        extends DeferredScalarSubscriberSafe<T,Map<K, Collection<V>>> {
+
+        private final Func1<? super T, ? extends K> keySelector;
+        private final Func1<? super T, ? extends V> valueSelector;
+        private final Func1<? super K, ? extends Collection<V>> collectionFactory;
+
+        ToMultimapSubscriber(
+            Subscriber<? super Map<K, Collection<V>>> subscriber, 
+            Map<K, Collection<V>> map,
+            Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector,
+            Func1<? super K, ? extends Collection<V>> collectionFactory) {
+            super(subscriber);
+            this.value = map;
+            this.hasValue = true;
+            this.keySelector = keySelector;
+            this.valueSelector = valueSelector;
+            this.collectionFactory = collectionFactory;
+        }
+        
+        @Override
+        public void onStart() {
+            request(Long.MAX_VALUE);
+        }
+
+        @Override
+        public void onNext(T t) {
+            if (done){
+                return;
+            }
+            try {
+                // any interaction with keySelector, valueSelector, collectionFactory, collection or value 
+                // may fail unexpectedly because their behaviour is customisable by the user. For this 
+                // reason we wrap their calls in try-catch block.
+                
+                K key = keySelector.call(t);
+                V v = valueSelector.call(t);
+                Collection<V> collection = value.get(key);
+                if (collection == null) {
+                    collection = collectionFactory.call(key);
+                    value.put(key, collection);
+                }
+                collection.add(v);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                onError(ex);
+            }
+
+          }
+    }
+        
+    /**
+     * The default collection factory for a key in the multimap returning
+     * an ArrayList independent of the key.
+     * @param <K> the key type
+     * @param <V> the value type
+     */
+    private static final class DefaultMultimapCollectionFactory<K, V>
+            implements Func1<K, Collection<V>> {
+        
+        private static final DefaultMultimapCollectionFactory<Object,Object> INSTANCE = new DefaultMultimapCollectionFactory<Object, Object>();
+        
+        @SuppressWarnings("unchecked")
+        static <K, V>  DefaultMultimapCollectionFactory<K,V> instance() {
+            return (DefaultMultimapCollectionFactory<K, V>) INSTANCE;
+        }
+        
+        @Override
+        public Collection<V> call(K t1) {
+            return new ArrayList<V>();
+        }
+    }
+    
+}
\ No newline at end of file
diff --git a/src/main/java/rx/internal/operators/OperatorToMultimap.java b/src/main/java/rx/internal/operators/OperatorToMultimap.java
deleted file mode 100644
index affdc080f4..0000000000
--- a/src/main/java/rx/internal/operators/OperatorToMultimap.java
+++ /dev/null
@@ -1,187 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- *
- * 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 rx.internal.operators;
-
-import java.util.*;
-
-import rx.Observable.Operator;
-import rx.Subscriber;
-import rx.exceptions.Exceptions;
-import rx.functions.*;
-import rx.observers.Subscribers;
-
-/**
- * Maps the elements of the source observable into a multimap
- * (Map&lt;K, Collection&lt;V>>) where each
- * key entry has a collection of the source's values.
- *
- * @see <a href="https://github.com/ReactiveX/RxJava/issues/97">Issue #97</a>
- * @param <T> the value type of the input
- * @param <K> the multimap-key type
- * @param <V> the multimap-value type
- */
-public final class OperatorToMultimap<T, K, V> implements Operator<Map<K, Collection<V>>, T> {
-
-    final Func1<? super T, ? extends K> keySelector;
-    final Func1<? super T, ? extends V> valueSelector;
-    private final Func0<? extends Map<K, Collection<V>>> mapFactory;
-    final Func1<? super K, ? extends Collection<V>> collectionFactory;
-
-    /**
-     * The default multimap factory returning a HashMap.
-     * @param <K> the key type
-     * @param <V> the value type
-     */
-    public static final class DefaultToMultimapFactory<K, V> implements Func0<Map<K, Collection<V>>> {
-        @Override
-        public Map<K, Collection<V>> call() {
-            return new HashMap<K, Collection<V>>();
-        }
-    }
-
-    /**
-     * The default collection factory for a key in the multimap returning
-     * an ArrayList independent of the key.
-     * @param <K> the key type
-     * @param <V> the value type
-     */
-    public static final class DefaultMultimapCollectionFactory<K, V>
-            implements Func1<K, Collection<V>> {
-        @Override
-        public Collection<V> call(K t1) {
-            return new ArrayList<V>();
-        }
-    }
-
-    /**
-     * ToMultimap with key selector, custom value selector,
-     * default HashMap factory and default ArrayList collection factory.
-     * @param keySelector the function extracting the map-key from the main value
-     * @param valueSelector the function extracting the map-value from the main value
-     */
-    public OperatorToMultimap(
-            Func1<? super T, ? extends K> keySelector,
-            Func1<? super T, ? extends V> valueSelector) {
-        this(keySelector, valueSelector,
-                new DefaultToMultimapFactory<K, V>(),
-                new DefaultMultimapCollectionFactory<K, V>());
-    }
-
-    /**
-     * ToMultimap with key selector, custom value selector,
-     * custom Map factory and default ArrayList collection factory.
-     * @param keySelector the function extracting the map-key from the main value
-     * @param valueSelector the function extracting the map-value from the main value
-     * @param mapFactory function that returns a Map instance to store keys and values into
-     */
-    public OperatorToMultimap(
-            Func1<? super T, ? extends K> keySelector,
-            Func1<? super T, ? extends V> valueSelector,
-            Func0<? extends Map<K, Collection<V>>> mapFactory) {
-        this(keySelector, valueSelector,
-                mapFactory,
-                new DefaultMultimapCollectionFactory<K, V>());
-    }
-
-    /**
-     * ToMultimap with key selector, custom value selector,
-     * custom Map factory and custom collection factory.
-     * @param keySelector the function extracting the map-key from the main value
-     * @param valueSelector the function extracting the map-value from the main value
-     * @param mapFactory function that returns a Map instance to store keys and values into
-     * @param collectionFactory function that returns a Collection for a particular key to store values into
-     */
-    public OperatorToMultimap(
-            Func1<? super T, ? extends K> keySelector,
-            Func1<? super T, ? extends V> valueSelector,
-            Func0<? extends Map<K, Collection<V>>> mapFactory,
-            Func1<? super K, ? extends Collection<V>> collectionFactory) {
-        this.keySelector = keySelector;
-        this.valueSelector = valueSelector;
-        this.mapFactory = mapFactory;
-        this.collectionFactory = collectionFactory;
-    }
-
-    @Override
-    public Subscriber<? super T> call(final Subscriber<? super Map<K, Collection<V>>> subscriber) {
-        
-        Map<K, Collection<V>> localMap;
-        
-        try {
-            localMap = mapFactory.call();
-        } catch (Throwable ex) {
-            Exceptions.throwIfFatal(ex);
-            subscriber.onError(ex);
-            
-            Subscriber<? super T> parent = Subscribers.empty();
-            parent.unsubscribe();
-            return parent;
-        }
-        
-        final Map<K, Collection<V>> fLocalMap = localMap;
-        
-        return new Subscriber<T>(subscriber) {
-            private Map<K, Collection<V>> map = fLocalMap;
-
-            @Override
-            public void onStart() {
-                request(Long.MAX_VALUE);
-            }
-            
-            @Override
-            public void onNext(T v) {
-                K key;
-                V value;
-
-                try {
-                    key = keySelector.call(v);
-                    value = valueSelector.call(v);
-                } catch (Throwable ex) {
-                    Exceptions.throwOrReport(ex, subscriber);
-                    return;
-                }
-                
-                Collection<V> collection = map.get(key);
-                if (collection == null) {
-                    try {
-                        collection = collectionFactory.call(key);
-                    } catch (Throwable ex) {
-                        Exceptions.throwOrReport(ex, subscriber);
-                        return;
-                    }
-                    map.put(key, collection);
-                }
-                collection.add(value);
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                map = null;
-                subscriber.onError(e);
-            }
-
-            @Override
-            public void onCompleted() {
-                Map<K, Collection<V>> map0 = map;
-                map = null;
-                subscriber.onNext(map0);
-                subscriber.onCompleted();
-            }
-
-        };
-    }
-}
\ No newline at end of file
diff --git a/src/test/java/rx/internal/operators/OperatorToMultimapTest.java b/src/test/java/rx/internal/operators/OnSubscribeToMultimapTest.java
similarity index 70%
rename from src/test/java/rx/internal/operators/OperatorToMultimapTest.java
rename to src/test/java/rx/internal/operators/OnSubscribeToMultimapTest.java
index f93f57500d..6177014bec 100644
--- a/src/test/java/rx/internal/operators/OperatorToMultimapTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToMultimapTest.java
@@ -15,6 +15,7 @@
  */
 package rx.internal.operators;
 
+import static org.junit.Assert.assertEquals;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
@@ -27,7 +28,9 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -36,15 +39,18 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.Producer;
+import rx.Subscriber;
+import rx.Observable.OnSubscribe;
 import rx.exceptions.TestException;
+import rx.functions.Action1;
 import rx.functions.Func0;
 import rx.functions.Func1;
-import rx.internal.operators.OperatorToMultimap.DefaultMultimapCollectionFactory;
-import rx.internal.operators.OperatorToMultimap.DefaultToMultimapFactory;
 import rx.internal.util.UtilityFunctions;
 import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
 
-public class OperatorToMultimapTest {
+public class OnSubscribeToMultimapTest {
     @Mock
     Observer<Object> objectObserver;
 
@@ -121,7 +127,7 @@ protected boolean removeEldestEntry(Map.Entry<Integer, Collection<String>> eldes
 
         Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(
                 lengthFunc, UtilityFunctions.<String>identity(),
-                mapFactory, new DefaultMultimapCollectionFactory<Integer, String>());
+                mapFactory, OnSubscribeToMultimapTest.<Integer, String>arrayListCollectionFactory());
 
         Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>();
         expected.put(2, Arrays.asList("cc", "dd"));
@@ -133,6 +139,25 @@ protected boolean removeEldestEntry(Map.Entry<Integer, Collection<String>> eldes
         verify(objectObserver, times(1)).onNext(expected);
         verify(objectObserver, times(1)).onCompleted();
     }
+    
+    private static final <K,V> Func1<K, Collection<V>> arrayListCollectionFactory() {
+        return new Func1<K, Collection<V>>() {
+
+            @Override
+            public Collection<V> call(K k) {
+                return new ArrayList<V>();
+            }};
+    }
+    
+    private static final <K, V> Func0<Map<K, Collection<V>>> multimapFactory() {
+        return new Func0<Map<K, Collection<V>>>() {
+
+            @Override
+            public Map<K, Collection<V>> call() {
+                return new HashMap<K, Collection<V>>();
+            }
+        };
+    }
 
     @Test
     public void testToMultimapWithCollectionFactory() {
@@ -152,7 +177,7 @@ public Collection<String> call(Integer t1) {
 
         Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(
                 lengthFunc, UtilityFunctions.<String>identity(),
-                new DefaultToMultimapFactory<Integer, String>(), collectionFactory);
+                OnSubscribeToMultimapTest.<Integer, String>multimapFactory(), collectionFactory);
 
         Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>();
         expected.put(2, Arrays.asList("cc", "dd"));
@@ -259,7 +284,7 @@ public Collection<String> call(Integer t1) {
             }
         };
 
-        Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFunc, UtilityFunctions.<String>identity(), new DefaultToMultimapFactory<Integer, String>(), collectionFactory);
+        Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFunc, UtilityFunctions.<String>identity(), OnSubscribeToMultimapTest.<Integer, String>multimapFactory(), collectionFactory);
 
         Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>();
         expected.put(2, Arrays.asList("cc", "dd"));
@@ -365,4 +390,127 @@ public Collection<Integer> call(Integer k) {
         ts.assertNoValues();
         ts.assertNotCompleted();
     }
+    
+    @Test
+    public void testKeySelectorFailureDoesNotAllowErrorAndCompletedEmissions() {
+        TestSubscriber<Map<Integer, Collection<Integer>>> ts = TestSubscriber.create(0);
+        final RuntimeException e = new RuntimeException();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 1) {
+                            sub.onNext(1);
+                            sub.onCompleted();
+                        }
+                    }
+                });
+            }
+        }).toMultimap(new Func1<Integer,Integer>() {
+
+            @Override
+            public Integer call(Integer t) {
+                throw e;
+            }
+        }).unsafeSubscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(e);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testKeySelectorFailureDoesNotAllowTwoErrorEmissions() {
+        try {
+            final List<Throwable> list = new CopyOnWriteArrayList<Throwable>();
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+
+                @Override
+                public void call(Throwable t) {
+                    list.add(t);
+                }
+            });
+            TestSubscriber<Map<Integer, Collection<Integer>>> ts = TestSubscriber.create(0);
+            final RuntimeException e1 = new RuntimeException();
+            final RuntimeException e2 = new RuntimeException();
+            Observable.create(new OnSubscribe<Integer>() {
+
+                @Override
+                public void call(final Subscriber<? super Integer> sub) {
+                    sub.setProducer(new Producer() {
+
+                        @Override
+                        public void request(long n) {
+                            if (n > 1) {
+                                sub.onNext(1);
+                                sub.onError(e2);
+                            }
+                        }
+                    });
+                }
+            }).toMultimap(new Func1<Integer, Integer>() {
+
+                @Override
+                public Integer call(Integer t) {
+                    throw e1;
+                }
+            }).unsafeSubscribe(ts);
+            ts.assertNoValues();
+            assertEquals(Arrays.asList(e1), ts.getOnErrorEvents());
+            assertEquals(Arrays.asList(e2), list);
+            ts.assertNotCompleted();
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+    
+    @Test
+    public void testFactoryFailureDoesNotAllowErrorThenOnNextEmissions() {
+        TestSubscriber<Map<Integer, Collection<Integer>>> ts = TestSubscriber.create(0);
+        final RuntimeException e = new RuntimeException();
+        Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> sub) {
+                sub.setProducer(new Producer() {
+
+                    @Override
+                    public void request(long n) {
+                        if (n > 1) {
+                            sub.onNext(1);
+                            sub.onNext(2);
+                        }
+                    }
+                });
+            }
+        }).toMultimap(new Func1<Integer,Integer>() {
+
+            @Override
+            public Integer call(Integer t) {
+                throw e;
+            }
+        }).unsafeSubscribe(ts);
+        ts.assertNoValues();
+        ts.assertError(e);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void testBackpressure() {
+        TestSubscriber<Object> ts = TestSubscriber.create(0);
+        Observable
+            .just("a", "bb", "ccc", "dddd")
+            .toMultimap(lengthFunc)
+            .subscribe(ts);
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+        ts.assertNoValues();
+        ts.requestMore(1);
+        ts.assertValueCount(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }    
 }

From 0f23a15c2b4cab8db74cce33118a5047b8c18a08 Mon Sep 17 00:00:00 2001
From: Sherif Makhlouf <sherifmakhlouf91@gmail.com>
Date: Tue, 2 Aug 2016 13:37:37 +0200
Subject: [PATCH 141/263] Adds Observable.sorted method (#4264)

* Adds Observable.sorted() method

* moves sorted tests to OperatorToObservableSortedListTest

* replace observer with testSubscriber

* adds a note about long or infinite sources

* makes inner class static
---
 src/main/java/rx/Observable.java              |  51 ++++++++
 .../OperatorToObservableSortedListTest.java   | 119 ++++++++++++++----
 2 files changed, 146 insertions(+), 24 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 9967a48eab..e08098bd18 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -11438,6 +11438,57 @@ public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Intege
         return lift(new OperatorToObservableSortedList<T>(sortFunction, initialCapacity));
     }
 
+    /**
+     * Returns an Observable that emits the events emitted by source Observable, in a
+     * sorted order. Each item emitted by the Observable must implement {@link Comparable} with respect to all
+     * other items in the sequence.
+     *
+     * <p>Note that calling {@code sorted} with long, non-terminating or infinite sources
+     * might cause {@link OutOfMemoryError}
+     *
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code sorted} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @throws ClassCastException
+     *             if any item emitted by the Observable does not implement {@link Comparable} with respect to
+     *             all other items emitted by the Observable
+     * @return an Observable that emits the items emitted by the source Observable in sorted order
+     */
+    @Experimental
+    public final Observable<T> sorted(){
+        return toSortedList().flatMapIterable(UtilityFunctions.<List<T>>identity());
+    }
+
+    /**
+     * Returns an Observable that emits the events emitted by source Observable, in a
+     * sorted order based on a specified comparison function.
+     *
+     * <p>Note that calling {@code sorted} with long, non-terminating or infinite sources
+     * might cause {@link OutOfMemoryError}
+     *
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
+     *  unbounded manner (i.e., without applying backpressure to it).</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code sorted} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param sortFunction
+     *            a function that compares two items emitted by the source Observable and returns an Integer
+     *            that indicates their sort order
+     * @return an Observable that emits the items emitted by the source Observable in sorted order
+     */
+    @Experimental
+    public final Observable<T> sorted(Func2<? super T, ? super T, Integer> sortFunction) {
+        return toSortedList(sortFunction).flatMapIterable(UtilityFunctions.<List<T>>identity());
+    }
+
     /**
      * Modifies the source Observable so that subscribers will unsubscribe from it on a specified
      * {@link Scheduler}.
diff --git a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
index f89d7d640b..6fa3b40647 100644
--- a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
+++ b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
@@ -40,12 +40,11 @@ public void testSortedList() {
         Observable<Integer> w = Observable.just(1, 3, 2, 5, 4);
         Observable<List<Integer>> observable = w.toSortedList();
 
-        @SuppressWarnings("unchecked")
-        Observer<List<Integer>> observer = mock(Observer.class);
-        observable.subscribe(observer);
-        verify(observer, times(1)).onNext(Arrays.asList(1, 2, 3, 4, 5));
-        verify(observer, Mockito.never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
+        TestSubscriber<List<Integer>> testSubscriber = new TestSubscriber<List<Integer>>();
+        observable.subscribe(testSubscriber);
+        testSubscriber.assertValue(Arrays.asList(1,2,3,4,5));
+        testSubscriber.assertNoErrors();
+        testSubscriber.assertCompleted();
     }
 
     @Test
@@ -154,12 +153,11 @@ public void testSortedListCapacity() {
         Observable<Integer> w = Observable.just(1, 3, 2, 5, 4);
         Observable<List<Integer>> observable = w.toSortedList(4);
 
-        @SuppressWarnings("unchecked")
-        Observer<List<Integer>> observer = mock(Observer.class);
-        observable.subscribe(observer);
-        verify(observer, times(1)).onNext(Arrays.asList(1, 2, 3, 4, 5));
-        verify(observer, Mockito.never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
+        TestSubscriber<List<Integer>> testSubscriber = new TestSubscriber<List<Integer>>();
+        observable.subscribe(testSubscriber);
+        testSubscriber.assertValue(Arrays.asList(1,2,3,4,5));
+        testSubscriber.assertNoErrors();
+        testSubscriber.assertCompleted();
     }
     
     @Test
@@ -172,12 +170,11 @@ public Integer call(Integer t1, Integer t2) {
             }
         });
 
-        @SuppressWarnings("unchecked")
-        Observer<List<Integer>> observer = mock(Observer.class);
-        observable.subscribe(observer);
-        verify(observer, times(1)).onNext(Arrays.asList(5, 4, 3, 2, 1));
-        verify(observer, Mockito.never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
+        TestSubscriber<List<Integer>> testSubscriber = new TestSubscriber<List<Integer>>();
+        observable.subscribe(testSubscriber);
+        testSubscriber.assertValue(Arrays.asList(5, 4, 3, 2, 1));
+        testSubscriber.assertNoErrors();
+        testSubscriber.assertCompleted();
     }
     
     @Test
@@ -190,11 +187,85 @@ public Integer call(Integer t1, Integer t2) {
             }
         }, 4);
 
-        @SuppressWarnings("unchecked")
-        Observer<List<Integer>> observer = mock(Observer.class);
-        observable.subscribe(observer);
-        verify(observer, times(1)).onNext(Arrays.asList(5, 4, 3, 2, 1));
-        verify(observer, Mockito.never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
+        TestSubscriber<List<Integer>> testSubscriber = new TestSubscriber<List<Integer>>();
+        observable.subscribe(testSubscriber);
+        testSubscriber.assertValue(Arrays.asList(5, 4, 3, 2, 1));
+        testSubscriber.assertNoErrors();
+        testSubscriber.assertCompleted();
+    }
+
+    @Test
+    public void testSorted() {
+        Observable<Integer> w = Observable.just(1, 3, 2, 5, 4);
+        Observable<Integer> observable = w.sorted();
+
+        TestSubscriber<Integer> testSubscriber = new TestSubscriber<Integer>();
+        observable.subscribe(testSubscriber);
+        testSubscriber.assertValues(1,2,3,4,5);
+        testSubscriber.assertNoErrors();
+        testSubscriber.assertCompleted();
+    }
+
+    @Test
+    public void testSortedWithCustomFunction() {
+        Observable<Integer> w = Observable.just(1, 3, 2, 5, 4);
+        Observable<Integer> observable = w.sorted(new Func2<Integer, Integer, Integer>() {
+
+            @Override
+            public Integer call(Integer t1, Integer t2) {
+                return t2 - t1;
+            }
+
+        });
+
+        TestSubscriber<Integer> testSubscriber = new TestSubscriber<Integer>();
+        observable.subscribe(testSubscriber);
+        testSubscriber.assertValues(5,4,3,2,1);
+        testSubscriber.assertNoErrors();
+        testSubscriber.assertCompleted();
+    }
+
+    @Test
+    public void testSortedCustomComparator() {
+        Observable<Integer> w = Observable.just(1, 3, 2, 5, 4);
+        Observable<Integer> observable = w.sorted(new Func2<Integer, Integer, Integer>() {
+            @Override
+            public Integer call(Integer t1, Integer t2) {
+                return t1.compareTo(t2);
+            }
+
+        });
+
+        TestSubscriber<Integer> testSubscriber = new TestSubscriber<Integer>();
+        observable.subscribe(testSubscriber);
+        testSubscriber.assertValues(1,2,3,4,5);
+        testSubscriber.assertNoErrors();
+        testSubscriber.assertCompleted();
+    }
+
+    @Test
+    public void testSortedWithNonComparable() {
+        NonComparable n1 = new NonComparable(1,"a");
+        NonComparable n2 = new NonComparable(2,"b");
+        NonComparable n3 = new NonComparable(3,"c");
+        Observable<NonComparable> w = Observable.just(n1,n2,n3);
+
+        Observable<NonComparable> observable = w.sorted();
+
+        TestSubscriber<NonComparable> testSubscriber = new TestSubscriber<NonComparable>();
+        observable.subscribe(testSubscriber);
+        testSubscriber.assertNoValues();
+        testSubscriber.assertError(ClassCastException.class);
+        testSubscriber.assertNotCompleted();
+    }
+
+    private final static class NonComparable{
+        public int i;
+        public String s;
+
+        NonComparable(int i, String s){
+            this.i = i;
+            this.s = s;
+        }
     }
 }

From 3690bd77157f31ec15c7cc02f8eb5ac28765e197 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Thu, 4 Aug 2016 11:59:59 +0200
Subject: [PATCH 142/263] 1.x: Remove needless static field for initialization
 in IndexedRingBuffer. (#4281)

---
 src/main/java/rx/internal/util/IndexedRingBuffer.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/internal/util/IndexedRingBuffer.java b/src/main/java/rx/internal/util/IndexedRingBuffer.java
index d5fc2f2e0b..1f2b1037d4 100644
--- a/src/main/java/rx/internal/util/IndexedRingBuffer.java
+++ b/src/main/java/rx/internal/util/IndexedRingBuffer.java
@@ -61,8 +61,6 @@ protected IndexedRingBuffer<?> createObject() {
 
     };
 
-    static int defaultSize = 256;
-
     /* package for unit testing */static final int SIZE;
 
     // default size of ring buffer
@@ -237,6 +235,8 @@ protected IndexedRingBuffer<?> createObject() {
      * } </pre>
      */
     static {
+        int defaultSize = 128;
+
         // lower default for Android (https://github.com/ReactiveX/RxJava/issues/1820)
         if (PlatformDependent.isAndroid()) {
             defaultSize = 8;

From 27c782dc4536ca318ffe0b698df6e5479e8ae4e9 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Fri, 5 Aug 2016 11:02:36 +0200
Subject: [PATCH 143/263] 1.x: Make Observable takeUntil documentation more
 explicit (#4282)

---
 src/main/java/rx/Observable.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index e08098bd18..2a3b4d7910 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -10511,7 +10511,7 @@ public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate)
 
     /**
      * Returns an Observable that emits items emitted by the source Observable, checks the specified predicate
-     * for each item, and then completes if the condition is satisfied.
+     * for each item, and then completes when the condition is satisfied.
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeUntil.p.png" alt="">
      * <p>
@@ -10529,7 +10529,7 @@ public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate)
      * @param stopPredicate 
      *            a function that evaluates an item emitted by the source Observable and returns a Boolean
      * @return an Observable that first emits items emitted by the source Observable, checks the specified
-     *         condition after each item, and then completes if the condition is satisfied.
+     *         condition after each item, and then completes when the condition is satisfied.
      * @see <a href="http://reactivex.io/documentation/operators/takeuntil.html">ReactiveX operators documentation: TakeUntil</a>
      * @see Observable#takeWhile(Func1)
      * @since 1.1.0

From b3a044675c4d63278287a83576a6b6a0eb8be1ee Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Mon, 8 Aug 2016 15:30:48 +0200
Subject: [PATCH 144/263] 1.x: Schedulers.from() to call
 RxJavaHooks.onScheduleAction (#4311)

---
 .../schedulers/ExecutorScheduler.java         |  9 +++-
 .../schedulers/ExecutorSchedulerTest.java     | 49 +++++++++++++++++--
 2 files changed, 52 insertions(+), 6 deletions(-)

diff --git a/src/main/java/rx/internal/schedulers/ExecutorScheduler.java b/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
index b4bcf19d7f..aa188fc96c 100644
--- a/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
+++ b/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
@@ -64,6 +64,9 @@ public Subscription schedule(Action0 action) {
             if (isUnsubscribed()) {
                 return Subscriptions.unsubscribed();
             }
+            
+            action = RxJavaHooks.onScheduledAction(action);
+            
             ScheduledAction ea = new ScheduledAction(action, tasks);
             tasks.add(ea);
             queue.offer(ea);
@@ -111,7 +114,7 @@ public void run() {
         }
         
         @Override
-        public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
+        public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
             if (delayTime <= 0) {
                 return schedule(action);
             }
@@ -119,6 +122,8 @@ public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit
                 return Subscriptions.unsubscribed();
             }
             
+            final Action0 decorated = RxJavaHooks.onScheduledAction(action);
+            
             final MultipleAssignmentSubscription first = new MultipleAssignmentSubscription();
             final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
             mas.set(first);
@@ -137,7 +142,7 @@ public void call() {
                         return;
                     }
                     // schedule the real action untimed
-                    Subscription s2 = schedule(action);
+                    Subscription s2 = schedule(decorated);
                     mas.set(s2);
                     // unless the worker is unsubscribed, we should get a new ScheduledAction
                     if (s2.getClass() == ScheduledAction.class) {
diff --git a/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java b/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java
index f80a32b041..a4f419f044 100644
--- a/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java
+++ b/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java
@@ -19,15 +19,16 @@
 
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicInteger;
-import org.junit.Test;
+
+import org.junit.*;
+
 import rx.*;
 import rx.Scheduler.Worker;
 import rx.functions.*;
 import rx.internal.schedulers.ExecutorScheduler.ExecutorSchedulerWorker;
 import rx.internal.util.RxThreadFactory;
-import rx.schedulers.AbstractSchedulerConcurrencyTests;
-import rx.schedulers.SchedulerTests;
-import rx.schedulers.Schedulers;
+import rx.plugins.RxJavaHooks;
+import rx.schedulers.*;
 
 public class ExecutorSchedulerTest extends AbstractSchedulerConcurrencyTests {
 
@@ -208,4 +209,44 @@ public void call() {
         
         assertFalse(w.tasks.hasSubscriptions());
     }
+    
+    @Test
+    public void actionHookCalled() throws Exception {
+        ExecutorService exec = Executors.newSingleThreadExecutor();
+        try {
+            final int[] call = { 0 };
+            
+            RxJavaHooks.setOnScheduleAction(new Func1<Action0, Action0>() {
+                @Override
+                public Action0 call(Action0 t) {
+                    call[0]++;
+                    return t;
+                }
+            });
+            
+            Scheduler s = Schedulers.from(exec);
+            
+            Worker w = s.createWorker();
+            
+            final CountDownLatch cdl = new CountDownLatch(1);
+            
+            try {
+                w.schedule(new Action0() {
+                    @Override
+                    public void call() {
+                        cdl.countDown();
+                    }
+                });
+                
+                Assert.assertTrue("Action timed out", cdl.await(5, TimeUnit.SECONDS));
+            } finally {
+                w.unsubscribe();
+            }
+            
+            Assert.assertEquals("Hook not called!", 1, call[0]);
+        } finally {
+            RxJavaHooks.reset();
+            exec.shutdown();
+        }
+    }
 }

From fabaa95d5b596be58d9638a8e008f9f4f29e4b63 Mon Sep 17 00:00:00 2001
From: Sherif Makhlouf <sherifmakhlouf91@gmail.com>
Date: Wed, 10 Aug 2016 18:23:14 +0200
Subject: [PATCH 145/263] 1.x: concatDelayError multiple arguments (#4261)

* Adds concatDelayError with multiple arguments

* Adds Tests for concatDelayError multiple arguments

* Updates wording
---
 src/main/java/rx/Observable.java              | 264 +++++++++++++++
 .../OnSubscribeConcatDelayErrorTest.java      | 313 ++++++++++++++++++
 2 files changed, 577 insertions(+)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 2a3b4d7910..badb31eaf1 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -1452,6 +1452,270 @@ public static <T> Observable<T> concatDelayError(Iterable<? extends Observable<?
         return concatDelayError(from(sources));
     }
 
+    /**
+     * Returns an Observable that emits the items emitted by two Observables, one after the other, without
+     * interleaving them, and delays any errors till all Observables terminate.
+     *
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well.
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T> the common element base type
+     * @param t1
+     *            an Observable to be concatenated
+     * @param t2
+     *            an Observable to be concatenated
+     * @return an Observable with the concatenating behavior
+     */
+    @Experimental
+    public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2) {
+        return concatDelayError(just(t1, t2));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by three Observables, one after the other, without
+     * interleaving them, and delays any errors till all Observables terminate.
+     *
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well.
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T> the common element base type
+     * @param t1
+     *            an Observable to be concatenated
+     * @param t2
+     *            an Observable to be concatenated
+     * @param t3
+     *            an Observable to be concatenated
+     * @return an Observable with the concatenating behavior
+     */
+    @Experimental
+    public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2,Observable<? extends T> t3 ) {
+        return concatDelayError(just(t1, t2, t3));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by four Observables, one after the other, without
+     * interleaving them, and delays any errors till all Observables terminate.
+     *
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well.
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T> the common element base type
+     * @param t1
+     *            an Observable to be concatenated
+     * @param t2
+     *            an Observable to be concatenated
+     * @param t3
+     *            an Observable to be concatenated
+     * @param t4
+     *            an Observable to be concatenated
+     * @return an Observable with the concatenating behavior
+     */
+    @Experimental
+    public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
+        return concatDelayError(just(t1, t2, t3, t4));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by five Observables, one after the other, without
+     * interleaving them, and delays any errors till all Observables terminate.
+     *
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well.
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T> the common element base type
+     * @param t1
+     *            an Observable to be concatenated
+     * @param t2
+     *            an Observable to be concatenated
+     * @param t3
+     *            an Observable to be concatenated
+     * @param t4
+     *            an Observable to be concatenated
+     * @param t5
+     *            an Observable to be concatenated
+     * @return an Observable with the concatenating behavior
+     */
+    @Experimental
+    public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
+        return concatDelayError(just(t1, t2, t3, t4, t5));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by six Observables, one after the other, without
+     * interleaving them, and delays any errors till all Observables terminate.
+     *
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well.
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T> the common element base type
+     * @param t1
+     *            an Observable to be concatenated
+     * @param t2
+     *            an Observable to be concatenated
+     * @param t3
+     *            an Observable to be concatenated
+     * @param t4
+     *            an Observable to be concatenated
+     * @param t5
+     *            an Observable to be concatenated
+     * @param t6
+     *            an Observable to be concatenated
+     * @return an Observable with the concatenating behavior
+     */
+    @Experimental
+    public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
+        return concatDelayError(just(t1, t2, t3, t4, t5, t6));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by seven Observables, one after the other, without
+     * interleaving them, and delays any errors till all Observables terminate.
+     *
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well.
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T> the common element base type
+     * @param t1
+     *            an Observable to be concatenated
+     * @param t2
+     *            an Observable to be concatenated
+     * @param t3
+     *            an Observable to be concatenated
+     * @param t4
+     *            an Observable to be concatenated
+     * @param t5
+     *            an Observable to be concatenated
+     * @param t6
+     *            an Observable to be concatenated
+     * @param t7
+     *            an Observable to be concatenated
+     * @return an Observable with the concatenating behavior
+     */
+    @Experimental
+    public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
+        return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by eight Observables, one after the other, without
+     * interleaving them, and delays any errors till all Observables terminate.
+     *
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well.
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T> the common element base type
+     * @param t1
+     *            an Observable to be concatenated
+     * @param t2
+     *            an Observable to be concatenated
+     * @param t3
+     *            an Observable to be concatenated
+     * @param t4
+     *            an Observable to be concatenated
+     * @param t5
+     *            an Observable to be concatenated
+     * @param t6
+     *            an Observable to be concatenated
+     * @param t7
+     *            an Observable to be concatenated
+     * @param t8
+     *            an Observable to be concatenated
+     * @return an Observable with the concatenating behavior
+     */
+    @Experimental
+    public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
+        return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7, t8));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by nine Observables, one after the other, without
+     * interleaving them, and delays any errors till all Observables terminate.
+     *
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well.
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T> the common element base type
+     * @param t1
+     *            an Observable to be concatenated
+     * @param t2
+     *            an Observable to be concatenated
+     * @param t3
+     *            an Observable to be concatenated
+     * @param t4
+     *            an Observable to be concatenated
+     * @param t5
+     *            an Observable to be concatenated
+     * @param t6
+     *            an Observable to be concatenated
+     * @param t7
+     *            an Observable to be concatenated
+     * @param t8
+     *            an Observable to be concatenated
+     * @param t9
+     *            an Observable to be concatenated
+     * @return an Observable with the concatenating behavior
+     */
+    @Experimental
+    public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
+        return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7, t8, t9));
+    }
+
     /**
      * Returns an Observable that calls an Observable factory to create an Observable for each new Observer
      * that subscribes. That is, for each subscriber, the actual Observable that subscriber observes is
diff --git a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
index 6fd947ae60..ee768ffc1a 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
@@ -277,4 +277,317 @@ public void concatDelayErrorIterableError() {
         assertEquals(2, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
     }
 
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError2() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> o1 = Observable.just(1);
+        Observable<Integer> o2 = Observable.just(2);
+
+        Observable.concatDelayError(o1, o2)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError2Error() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> withError1 = withError(Observable.just(1));
+        Observable<Integer> withError2 = withError(Observable.just(2));
+
+        Observable.concatDelayError(withError1, withError2)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2);
+        ts.assertError(CompositeException.class);
+        ts.assertNotCompleted();
+
+        assertEquals(2, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError3() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> o1 = Observable.just(1);
+        Observable<Integer> o2 = Observable.just(2);
+        Observable<Integer> o3 = Observable.just(3);
+
+        Observable.concatDelayError(o1, o2, o3)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError3Error() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> withError1 = withError(Observable.just(1));
+        Observable<Integer> withError2 = withError(Observable.just(2));
+        Observable<Integer> withError3 = withError(Observable.just(3));
+
+        Observable.concatDelayError(withError1, withError2, withError3)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3);
+        ts.assertError(CompositeException.class);
+        ts.assertNotCompleted();
+
+        assertEquals(3, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError4() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> o1 = Observable.just(1);
+        Observable<Integer> o2 = Observable.just(2);
+        Observable<Integer> o3 = Observable.just(3);
+        Observable<Integer> o4 = Observable.just(4);
+
+        Observable.concatDelayError(o1, o2, o3, o4)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError4Error() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> withError1 = withError(Observable.just(1));
+        Observable<Integer> withError2 = withError(Observable.just(2));
+        Observable<Integer> withError3 = withError(Observable.just(3));
+        Observable<Integer> withError4 = withError(Observable.just(4));
+
+        Observable.concatDelayError(withError1, withError2, withError3, withError4)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4);
+        ts.assertError(CompositeException.class);
+        ts.assertNotCompleted();
+
+        assertEquals(4, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError5() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> o1 = Observable.just(1);
+        Observable<Integer> o2 = Observable.just(2);
+        Observable<Integer> o3 = Observable.just(3);
+        Observable<Integer> o4 = Observable.just(4);
+        Observable<Integer> o5 = Observable.just(5);
+
+        Observable.concatDelayError(o1, o2, o3, o4, o5)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError5Error() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> withError1 = withError(Observable.just(1));
+        Observable<Integer> withError2 = withError(Observable.just(2));
+        Observable<Integer> withError3 = withError(Observable.just(3));
+        Observable<Integer> withError4 = withError(Observable.just(4));
+        Observable<Integer> withError5 = withError(Observable.just(5));
+
+        Observable.concatDelayError(withError1, withError2, withError3, withError4, withError5)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4, 5);
+        ts.assertError(CompositeException.class);
+        ts.assertNotCompleted();
+
+        assertEquals(5, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError6() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> o1 = Observable.just(1);
+        Observable<Integer> o2 = Observable.just(2);
+        Observable<Integer> o3 = Observable.just(3);
+        Observable<Integer> o4 = Observable.just(4);
+        Observable<Integer> o5 = Observable.just(5);
+        Observable<Integer> o6 = Observable.just(6);
+
+        Observable.concatDelayError(o1, o2, o3, o4, o5, o6)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4, 5, 6);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError6Error() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> withError1 = withError(Observable.just(1));
+        Observable<Integer> withError2 = withError(Observable.just(2));
+        Observable<Integer> withError3 = withError(Observable.just(3));
+        Observable<Integer> withError4 = withError(Observable.just(4));
+        Observable<Integer> withError5 = withError(Observable.just(5));
+        Observable<Integer> withError6 = withError(Observable.just(6));
+
+        Observable.concatDelayError(withError1, withError2, withError3, withError4, withError5, withError6)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4, 5, 6);
+        ts.assertError(CompositeException.class);
+        ts.assertNotCompleted();
+
+        assertEquals(6, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError7() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> o1 = Observable.just(1);
+        Observable<Integer> o2 = Observable.just(2);
+        Observable<Integer> o3 = Observable.just(3);
+        Observable<Integer> o4 = Observable.just(4);
+        Observable<Integer> o5 = Observable.just(5);
+        Observable<Integer> o6 = Observable.just(6);
+        Observable<Integer> o7 = Observable.just(7);
+
+        Observable.concatDelayError(o1, o2, o3, o4, o5, o6, o7)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4, 5, 6, 7);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError7Error() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> withError1 = withError(Observable.just(1));
+        Observable<Integer> withError2 = withError(Observable.just(2));
+        Observable<Integer> withError3 = withError(Observable.just(3));
+        Observable<Integer> withError4 = withError(Observable.just(4));
+        Observable<Integer> withError5 = withError(Observable.just(5));
+        Observable<Integer> withError6 = withError(Observable.just(6));
+        Observable<Integer> withError7 = withError(Observable.just(7));
+
+        Observable.concatDelayError(withError1, withError2, withError3, withError4, withError5, withError6, withError7)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4, 5, 6, 7);
+        ts.assertError(CompositeException.class);
+        ts.assertNotCompleted();
+
+        assertEquals(7, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError8() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> o1 = Observable.just(1);
+        Observable<Integer> o2 = Observable.just(2);
+        Observable<Integer> o3 = Observable.just(3);
+        Observable<Integer> o4 = Observable.just(4);
+        Observable<Integer> o5 = Observable.just(5);
+        Observable<Integer> o6 = Observable.just(6);
+        Observable<Integer> o7 = Observable.just(7);
+        Observable<Integer> o8 = Observable.just(8);
+
+
+        Observable.concatDelayError(o1, o2, o3, o4, o5, o6, o7, o8)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError8Error() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> withError1 = withError(Observable.just(1));
+        Observable<Integer> withError2 = withError(Observable.just(2));
+        Observable<Integer> withError3 = withError(Observable.just(3));
+        Observable<Integer> withError4 = withError(Observable.just(4));
+        Observable<Integer> withError5 = withError(Observable.just(5));
+        Observable<Integer> withError6 = withError(Observable.just(6));
+        Observable<Integer> withError7 = withError(Observable.just(7));
+        Observable<Integer> withError8 = withError(Observable.just(8));
+
+        Observable.concatDelayError(withError1, withError2, withError3, withError4, withError5, withError6, withError7, withError8)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8);
+        ts.assertError(CompositeException.class);
+        ts.assertNotCompleted();
+
+        assertEquals(8, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError9() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> o1 = Observable.just(1);
+        Observable<Integer> o2 = Observable.just(2);
+        Observable<Integer> o3 = Observable.just(3);
+        Observable<Integer> o4 = Observable.just(4);
+        Observable<Integer> o5 = Observable.just(5);
+        Observable<Integer> o6 = Observable.just(6);
+        Observable<Integer> o7 = Observable.just(7);
+        Observable<Integer> o8 = Observable.just(8);
+        Observable<Integer> o9 = Observable.just(9);
+
+
+        Observable.concatDelayError(o1, o2, o3, o4, o5, o6, o7, o8, o9)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void concatDelayError9Error() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        Observable<Integer> withError1 = withError(Observable.just(1));
+        Observable<Integer> withError2 = withError(Observable.just(2));
+        Observable<Integer> withError3 = withError(Observable.just(3));
+        Observable<Integer> withError4 = withError(Observable.just(4));
+        Observable<Integer> withError5 = withError(Observable.just(5));
+        Observable<Integer> withError6 = withError(Observable.just(6));
+        Observable<Integer> withError7 = withError(Observable.just(7));
+        Observable<Integer> withError8 = withError(Observable.just(8));
+        Observable<Integer> withError9 = withError(Observable.just(9));
+
+        Observable.concatDelayError(withError1, withError2, withError3, withError4, withError5, withError6, withError7, withError8, withError9)
+                .subscribe(ts);
+
+        ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9);
+        ts.assertError(CompositeException.class);
+        ts.assertNotCompleted();
+
+        assertEquals(9, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
+    }
 }

From d0b3bee3eea0a90384d44a03edd7b425a8a2ed77 Mon Sep 17 00:00:00 2001
From: Paul Woitaschek <woitaschek@posteo.de>
Date: Wed, 10 Aug 2016 18:33:38 +0200
Subject: [PATCH 146/263] Added Observable.concat(Iterable) (#4330)

* Added Observable.concat(Iterable)

* Adjusted testConcatWithIterableOfObservable to really test iterables. Before it was testing the same as testConcatWithObservableOfObservable
---
 src/main/java/rx/Observable.java  | 26 ++++++++++++++++++++++++++
 src/test/java/rx/ConcatTests.java |  2 +-
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index badb31eaf1..f17ab86dc2 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -1101,6 +1101,32 @@ public static <T, R> Observable<R> combineLatestDelayError(Iterable<? extends Ob
         return create(new OnSubscribeCombineLatest<T, R>(null, sources, combineFunction, RxRingBuffer.SIZE, true));
     }
 
+    /**
+     * Flattens an Iterable of Observables into one Observable, one after the other, without
+     * interleaving them.
+     * <p>
+     * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png" alt="">
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator honors backpressure from downstream. The {@code Observable}
+     *  sources are expected to honor backpressure as well.
+     *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
+     *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param <T> the common element base type
+     * @param sequences
+     *            the Iterable of Observables
+     * @return an Observable that emits items that are the result of flattening the items emitted by the
+     *         Observables in the Iterable, one after the other, without interleaving them
+     * @see <a href="http://reactivex.io/documentation/operators/concat.html">ReactiveX operators documentation: Concat</a>
+     */
+    public static <T> Observable<T> concat(Iterable<? extends Observable<? extends T>> sequences) {
+        return concat(from(sequences));
+    }
+
     /**
      * Returns an Observable that emits the items emitted by each of the Observables emitted by the source
      * Observable, one after the other, without interleaving them.
diff --git a/src/test/java/rx/ConcatTests.java b/src/test/java/rx/ConcatTests.java
index c231b59109..e357ea5030 100644
--- a/src/test/java/rx/ConcatTests.java
+++ b/src/test/java/rx/ConcatTests.java
@@ -69,7 +69,7 @@ public void testConcatWithIterableOfObservable() {
         @SuppressWarnings("unchecked")
         Iterable<Observable<String>> is = Arrays.asList(o1, o2, o3);
 
-        List<String> values = Observable.concat(Observable.from(is)).toList().toBlocking().single();
+        List<String> values = Observable.concat(is).toList().toBlocking().single();
 
         assertEquals("one", values.get(0));
         assertEquals("two", values.get(1));

From cd0301b6f5540e5632fff10f57e0113de30500aa Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 11 Aug 2016 13:34:10 +0200
Subject: [PATCH 147/263] 1.x: compact MultipleAssignment- and
 Serial-Subscriptions (#4328)

* 1.x: compact MultipleAssignment- and Serial-Subscriptions

* Update javadoc - mention unsubscription
---
 src/main/java/rx/Scheduler.java               |  16 +-
 .../subscriptions/SequentialSubscription.java | 189 ++++++++++++++++++
 .../internal/subscriptions/Unsubscribed.java  |  35 ++++
 .../MultipleAssignmentSubscription.java       |  57 +-----
 .../rx/subscriptions/SerialSubscription.java  |  73 ++-----
 .../MultipleAssignmentSubscriptionTest.java   |  23 ++-
 6 files changed, 269 insertions(+), 124 deletions(-)
 create mode 100644 src/main/java/rx/internal/subscriptions/SequentialSubscription.java
 create mode 100644 src/main/java/rx/internal/subscriptions/Unsubscribed.java

diff --git a/src/main/java/rx/Scheduler.java b/src/main/java/rx/Scheduler.java
index 1487373fcc..ee5f70ec46 100644
--- a/src/main/java/rx/Scheduler.java
+++ b/src/main/java/rx/Scheduler.java
@@ -18,11 +18,10 @@
 import java.util.concurrent.TimeUnit;
 
 import rx.annotations.Experimental;
-import rx.functions.Action0;
-import rx.functions.Func1;
+import rx.functions.*;
 import rx.internal.schedulers.SchedulerWhen;
+import rx.internal.subscriptions.SequentialSubscription;
 import rx.schedulers.Schedulers;
-import rx.subscriptions.MultipleAssignmentSubscription;
 
 /**
  * A {@code Scheduler} is an object that schedules units of work. You can find common implementations of this
@@ -126,7 +125,9 @@ public Subscription schedulePeriodically(final Action0 action, long initialDelay
             final long firstNowNanos = TimeUnit.MILLISECONDS.toNanos(now());
             final long firstStartInNanos = firstNowNanos + unit.toNanos(initialDelay);
 
-            final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
+            final SequentialSubscription first = new SequentialSubscription();
+            final SequentialSubscription mas = new SequentialSubscription(first);
+            
             final Action0 recursiveAction = new Action0() {
                 long count;
                 long lastNowNanos = firstNowNanos;
@@ -155,14 +156,11 @@ public void call() {
                         lastNowNanos = nowNanos;
                         
                         long delay = nextTick - nowNanos;
-                        mas.set(schedule(this, delay, TimeUnit.NANOSECONDS));
+                        mas.replace(schedule(this, delay, TimeUnit.NANOSECONDS));
                     }
                 }
             };
-            MultipleAssignmentSubscription s = new MultipleAssignmentSubscription();
-            // Should call `mas.set` before `schedule`, or the new Subscription may replace the old one.
-            mas.set(s);
-            s.set(schedule(recursiveAction, initialDelay, unit));
+            first.replace(schedule(recursiveAction, initialDelay, unit));
             return mas;
         }
 
diff --git a/src/main/java/rx/internal/subscriptions/SequentialSubscription.java b/src/main/java/rx/internal/subscriptions/SequentialSubscription.java
new file mode 100644
index 0000000000..4c65e157e7
--- /dev/null
+++ b/src/main/java/rx/internal/subscriptions/SequentialSubscription.java
@@ -0,0 +1,189 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * 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 rx.internal.subscriptions;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import rx.Subscription;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * A container of a Subscription that supports operations of SerialSubscription 
+ * and MultipleAssignmentSubscription via methods (update, replace) and extends
+ * AtomicReference to reduce allocation count (beware the API leak of AtomicReference!).
+ * @since 1.1.9
+ */
+public final class SequentialSubscription extends AtomicReference<Subscription> implements Subscription {
+
+    /** */
+    private static final long serialVersionUID = 995205034283130269L;
+
+    /**
+     * Create an empty SequentialSubscription.
+     */
+    public SequentialSubscription() {
+        
+    }
+    
+    /**
+     * Create a SequentialSubscription with the given initial Subscription.
+     * @param initial the initial Subscription, may be null
+     */
+    public SequentialSubscription(Subscription initial) {
+        lazySet(initial);
+    }
+    
+    /**
+     * Returns the current contained Subscription (may be null).
+     * <p>(Remark: named as such because get() is final).
+     * @return the current contained Subscription (may be null)
+     */
+    public Subscription current() {
+        Subscription current = super.get();
+        if (current == Unsubscribed.INSTANCE) {
+            return Subscriptions.unsubscribed();
+        }
+        return current;
+    }
+    
+    /**
+     * Atomically sets the contained Subscription to the provided next value and unsubscribes
+     * the previous value or unsubscribes the next value if this container is unsubscribed.
+     * <p>(Remark: named as such because set() is final).
+     * @param next the next Subscription to contain, may be null
+     * @return true if the update succeded, false if the container was unsubscribed
+     */
+    public boolean update(Subscription next) {
+        for (;;) {
+            Subscription current = get();
+
+            if (current == Unsubscribed.INSTANCE) {
+                if (next != null) {
+                    next.unsubscribe();
+                }
+                return false;
+            }
+            
+            if (compareAndSet(current, next)) {
+                if (current != null) {
+                    current.unsubscribe();
+                }
+                return true;
+            }
+        }
+    }
+
+    /**
+     * Atomically replaces the contained Subscription to the provided next value but
+     * does not unsubscribe the previous value or unsubscribes the next value if this 
+     * container is unsubscribed.
+     * @param next the next Subscription to contain, may be null
+     * @return true if the update succeded, false if the container was unsubscribed
+     */
+    public boolean replace(Subscription next) {
+        for (;;) {
+            Subscription current = get();
+
+            if (current == Unsubscribed.INSTANCE) {
+                if (next != null) {
+                    next.unsubscribe();
+                }
+                return false;
+            }
+            
+            if (compareAndSet(current, next)) {
+                return true;
+            }
+        }
+    }
+    
+    /**
+     * Atomically tries to set the contained Subscription to the provided next value and unsubscribes
+     * the previous value or unsubscribes the next value if this container is unsubscribed.
+     * <p>
+     * Unlike {@link #update(Subscription)}, this doesn't retry if the replace failed
+     * because a concurrent operation changed the underlying contained object.
+     * @param next the next Subscription to contain, may be null
+     * @return true if the update succeded, false if the container was unsubscribed
+     */
+    public boolean updateWeak(Subscription next) {
+        Subscription current = get();
+        if (current == Unsubscribed.INSTANCE) {
+            if (next != null) {
+                next.unsubscribe();
+            }
+            return false;
+        }
+        if (compareAndSet(current, next)) {
+            return true;
+        }
+        
+        current = get();
+        
+        if (next != null) {
+            next.unsubscribe();
+        }
+        return current == Unsubscribed.INSTANCE;
+    }
+    
+    /**
+     * Atomically tries to replace the contained Subscription to the provided next value but
+     * does not unsubscribe the previous value or unsubscribes the next value if this container 
+     * is unsubscribed.
+     * <p>
+     * Unlike {@link #replace(Subscription)}, this doesn't retry if the replace failed
+     * because a concurrent operation changed the underlying contained object.
+     * @param next the next Subscription to contain, may be null
+     * @return true if the update succeded, false if the container was unsubscribed
+     */
+    public boolean replaceWeak(Subscription next) {
+        Subscription current = get();
+        if (current == Unsubscribed.INSTANCE) {
+            if (next != null) {
+                next.unsubscribe();
+            }
+            return false;
+        }
+        if (compareAndSet(current, next)) {
+            return true;
+        }
+        
+        current = get();
+        if (current == Unsubscribed.INSTANCE) {
+            if (next != null) {
+                next.unsubscribe();
+            }
+            return false;
+        }
+        return true;
+    }
+    
+    @Override
+    public void unsubscribe() {
+        Subscription current = get();
+        if (current != Unsubscribed.INSTANCE) {
+            current = getAndSet(Unsubscribed.INSTANCE);
+            if (current != null && current != Unsubscribed.INSTANCE) {
+                current.unsubscribe();
+            }
+        }
+    }
+    
+    @Override
+    public boolean isUnsubscribed() {
+        return get() == Unsubscribed.INSTANCE;
+    }
+}
diff --git a/src/main/java/rx/internal/subscriptions/Unsubscribed.java b/src/main/java/rx/internal/subscriptions/Unsubscribed.java
new file mode 100644
index 0000000000..3bc85c7e9a
--- /dev/null
+++ b/src/main/java/rx/internal/subscriptions/Unsubscribed.java
@@ -0,0 +1,35 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.subscriptions;
+
+import rx.Subscription;
+
+/**
+ * Represents an unsubscribed Subscription via a singleton; don't leak it!
+ */
+public enum Unsubscribed implements Subscription {
+    INSTANCE;
+    
+    @Override
+    public boolean isUnsubscribed() {
+        return true;
+    }
+    
+    @Override
+    public void unsubscribe() {
+        // deliberately ignored
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java b/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
index 1418a5684c..ee58c2ea77 100644
--- a/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
+++ b/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
@@ -15,10 +15,8 @@
  */
 package rx.subscriptions;
 
-import java.util.concurrent.atomic.AtomicReference;
-
-import rx.Observable;
-import rx.Subscription;
+import rx.*;
+import rx.internal.subscriptions.SequentialSubscription;
 
 /**
  * Subscription that can be checked for status such as in a loop inside an {@link Observable} to exit the loop
@@ -26,45 +24,16 @@
  */
 public final class MultipleAssignmentSubscription implements Subscription {
 
-    final AtomicReference<State> state = new AtomicReference<State>(new State(false, Subscriptions.empty()));
+    final SequentialSubscription state = new SequentialSubscription();
     
-    static final class State {
-        final boolean isUnsubscribed;
-        final Subscription subscription;
-
-        State(boolean u, Subscription s) {
-            this.isUnsubscribed = u;
-            this.subscription = s;
-        }
-
-        State unsubscribe() {
-            return new State(true, subscription);
-        }
-
-        State set(Subscription s) {
-            return new State(isUnsubscribed, s);
-        }
-
-    }
     @Override
     public boolean isUnsubscribed() {
-        return state.get().isUnsubscribed;
+        return state.isUnsubscribed();
     }
 
     @Override
     public void unsubscribe() {
-        State oldState;
-        State newState;
-        final AtomicReference<State> localState = this.state;
-        do {
-            oldState = localState.get();
-            if (oldState.isUnsubscribed) {
-                return;
-            } else {
-                newState = oldState.unsubscribe();
-            }
-        } while (!localState.compareAndSet(oldState, newState));
-        oldState.subscription.unsubscribe();
+        state.unsubscribe();
     }
 
     /**
@@ -78,18 +47,7 @@ public void set(Subscription s) {
         if (s == null) {
             throw new IllegalArgumentException("Subscription can not be null");
         }
-        State oldState;
-        State newState;
-        final AtomicReference<State> localState = this.state;
-        do {
-            oldState = localState.get();
-            if (oldState.isUnsubscribed) {
-                s.unsubscribe();
-                return;
-            } else {
-                newState = oldState.set(s);
-            }
-        } while (!localState.compareAndSet(oldState, newState));
+        state.replace(s);
     }
 
     /**
@@ -98,7 +56,6 @@ public void set(Subscription s) {
      * @return the {@link Subscription} that underlies the {@code MultipleAssignmentSubscription}
      */
     public Subscription get() {
-        return state.get().subscription;
+        return state.current();
     }
-
 }
diff --git a/src/main/java/rx/subscriptions/SerialSubscription.java b/src/main/java/rx/subscriptions/SerialSubscription.java
index b06503f761..5b9590ed25 100644
--- a/src/main/java/rx/subscriptions/SerialSubscription.java
+++ b/src/main/java/rx/subscriptions/SerialSubscription.java
@@ -15,91 +15,48 @@
  */
 package rx.subscriptions;
 
-import java.util.concurrent.atomic.AtomicReference;
-
 import rx.Subscription;
+import rx.internal.subscriptions.SequentialSubscription;
 
 /**
  * Represents a subscription whose underlying subscription can be swapped for another subscription which causes
  * the previous underlying subscription to be unsubscribed.
  */
 public final class SerialSubscription implements Subscription {
-    final AtomicReference<State> state = new AtomicReference<State>(new State(false, Subscriptions.empty()));
-
-    static final class State {
-        final boolean isUnsubscribed;
-        final Subscription subscription;
-
-        State(boolean u, Subscription s) {
-            this.isUnsubscribed = u;
-            this.subscription = s;
-        }
-
-        State unsubscribe() {
-            return new State(true, subscription);
-        }
-
-        State set(Subscription s) {
-            return new State(isUnsubscribed, s);
-        }
-
-    }
-
+    
+    final SequentialSubscription state = new SequentialSubscription();
+    
     @Override
     public boolean isUnsubscribed() {
-        return state.get().isUnsubscribed;
+        return state.isUnsubscribed();
     }
 
     @Override
     public void unsubscribe() {
-        State oldState;
-        State newState;
-        final AtomicReference<State> localState = this.state;
-        do {
-            oldState = localState.get();
-            if (oldState.isUnsubscribed) {
-                return;
-            } else {
-                newState = oldState.unsubscribe();
-            }
-        } while (!localState.compareAndSet(oldState, newState));
-        oldState.subscription.unsubscribe();
+        state.unsubscribe();
     }
 
     /**
-     * Swaps out the old {@link Subscription} for the specified {@code Subscription}.
+     * Sets the underlying subscription. If the {@code MultipleAssignmentSubscription} is already unsubscribed,
+     * setting a new subscription causes the new subscription to also be immediately unsubscribed.
      *
-     * @param s
-     *          the new {@code Subscription} to swap in
-     * @throws IllegalArgumentException
-     *          if {@code s} is {@code null}
+     * @param s the {@link Subscription} to set
+     * @throws IllegalArgumentException if {@code s} is {@code null}
      */
     public void set(Subscription s) {
         if (s == null) {
             throw new IllegalArgumentException("Subscription can not be null");
         }
-        State oldState;
-        State newState;
-        final AtomicReference<State> localState = this.state;
-        do {
-            oldState = localState.get();
-            if (oldState.isUnsubscribed) {
-                s.unsubscribe();
-                return;
-            } else {
-                newState = oldState.set(s);
-            }
-        } while (!localState.compareAndSet(oldState, newState));
-        oldState.subscription.unsubscribe();
+        state.update(s);
     }
 
     /**
-     * Retrieves the current {@link Subscription} that is being represented by this {@code SerialSubscription}.
-     * 
-     * @return the current {@link Subscription} that is being represented by this {@code SerialSubscription}
+     * Gets the underlying subscription.
+     *
+     * @return the {@link Subscription} that underlies the {@code MultipleAssignmentSubscription}
      */
     public Subscription get() {
-        return state.get().subscription;
+        return state.current();
     }
 
 }
diff --git a/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java b/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
index 358f500ec3..2db843a420 100644
--- a/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
+++ b/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
@@ -15,15 +15,11 @@
  */
 package rx.subscriptions;
 
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 import static rx.subscriptions.Subscriptions.create;
-import org.junit.Assert;
 
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.*;
 
 import rx.Subscription;
 import rx.functions.Action0;
@@ -72,6 +68,7 @@ public void subscribingWhenUnsubscribedCausesImmediateUnsubscription() {
     }
 
     @Test
+    @Ignore("This is prone to leaks")
     public void testSubscriptionRemainsAfterUnsubscribe() {
         MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
 
@@ -80,4 +77,16 @@ public void testSubscriptionRemainsAfterUnsubscribe() {
 
         Assert.assertEquals(true, mas.get() == s);
     }
+
+    @Test
+    public void subscriptionDoesntRemainAfterUnsubscribe() {
+        MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
+
+        mas.set(s);
+        mas.unsubscribe();
+
+        assertNotEquals(s, mas.get());
+        assertSame(mas.get(), Subscriptions.unsubscribed());
+    }
+
 }
\ No newline at end of file

From 90744100e679e673a56410ecee145bb4ce85ab6d Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 11 Aug 2016 13:59:47 +0200
Subject: [PATCH 148/263] 1.x: add TestSubscriber.assertValuesAndClear (#4322)

* 1.x: add TestSubscriber.assertAndConsume

* Rename to assertValuesAndClear()

* Update javadoc example

* Tag as experimental
---
 .../java/rx/observers/TestSubscriber.java     | 58 +++++++++++++++----
 .../java/rx/observers/TestSubscriberTest.java | 43 ++++++++++++++
 2 files changed, 89 insertions(+), 12 deletions(-)

diff --git a/src/main/java/rx/observers/TestSubscriber.java b/src/main/java/rx/observers/TestSubscriber.java
index c40593af55..43399def27 100644
--- a/src/main/java/rx/observers/TestSubscriber.java
+++ b/src/main/java/rx/observers/TestSubscriber.java
@@ -328,19 +328,22 @@ public void assertReceivedOnNext(List<T> items) {
         }
 
         for (int i = 0; i < items.size(); i++) {
-            T expected = items.get(i);
-            T actual = values.get(i);
-            if (expected == null) {
-                // check for null equality
-                if (actual != null) {
-                    assertionError("Value at index: " + i + " expected to be [null] but was: [" + actual + "]\n");
-                }
-            } else if (!expected.equals(actual)) {
-                assertionError("Value at index: " + i 
-                        + " expected to be [" + expected + "] (" + expected.getClass().getSimpleName() 
-                        + ") but was: [" + actual + "] (" + (actual != null ? actual.getClass().getSimpleName() : "null") + ")\n");
-
+            assertItem(items.get(i), i);
+        }
+    }
+    
+    private void assertItem(T expected, int i) {
+        T actual = values.get(i);
+        if (expected == null) {
+            // check for null equality
+            if (actual != null) {
+                assertionError("Value at index: " + i + " expected to be [null] but was: [" + actual + "]\n");
             }
+        } else if (!expected.equals(actual)) {
+            assertionError("Value at index: " + i 
+                    + " expected to be [" + expected + "] (" + expected.getClass().getSimpleName() 
+                    + ") but was: [" + actual + "] (" + (actual != null ? actual.getClass().getSimpleName() : "null") + ")\n");
+
         }
     }
 
@@ -670,4 +673,35 @@ final void assertionError(String message) {
         }
         throw ae;
     }
+    
+    /**
+     * Assert that the TestSubscriber contains the given first and optional rest values exactly
+     * and if so, clears the internal list of values.
+     * <p>
+     * <code><pre>
+     * TestSubscriber ts = new TestSubscriber();
+     * 
+     * ts.onNext(1);
+     * 
+     * ts.assertValuesAndClear(1);
+     * 
+     * ts.onNext(2);
+     * ts.onNext(3);
+     * 
+     * ts.assertValuesAndClear(2, 3); // no mention of 1
+     * </pre></code>
+     * @param expectedFirstValue the expected first value
+     * @param expectedRestValues the optional rest values
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final void assertValuesAndClear(T expectedFirstValue, T... expectedRestValues) {
+        int n = 1 + expectedRestValues.length;
+        assertValueCount(n);
+        assertItem(expectedFirstValue, 0);
+        for (int i = 0; i < expectedRestValues.length; i++) {
+            assertItem(expectedRestValues[i], i + 1);
+        }
+        values.clear();
+    }
 }
diff --git a/src/test/java/rx/observers/TestSubscriberTest.java b/src/test/java/rx/observers/TestSubscriberTest.java
index f5d1146c14..b5830822f8 100644
--- a/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/src/test/java/rx/observers/TestSubscriberTest.java
@@ -772,4 +772,47 @@ public void awaitValueCountFails() throws Exception {
         Assert.assertFalse(ts.awaitValueCount(5, 1, TimeUnit.SECONDS));
         
     }
+    
+    @Test
+    public void assertAndConsume() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+        
+        ts.assertNoValues();
+        
+        ts.onNext(1);
+        
+        ts.assertValuesAndClear(1);
+        
+        ts.assertNoValues();
+        
+        ts.onNext(2);
+        ts.onNext(3);
+        
+        ts.assertValueCount(2);
+        
+        ts.assertValuesAndClear(2, 3);
+        
+        ts.onNext(4);
+        ts.onNext(5);
+        
+        try {
+            ts.assertValuesAndClear(4);
+            Assert.fail("Should have thrown AssertionError");
+        } catch (AssertionError ex) {
+            // expected
+        }
+        
+        ts.assertValueCount(2);
+        
+        try {
+            ts.assertValuesAndClear(4, 5, 6);
+            Assert.fail("Should have thrown AssertionError");
+        } catch (AssertionError ex) {
+            // expected
+        }
+        
+        ts.assertValuesAndClear(4, 5);
+        
+        ts.assertNoValues();
+    }
 }

From 3c7f41cd20d36b2e2e32141eaddbc1628d4667db Mon Sep 17 00:00:00 2001
From: Shintaro Katafuchi <hotchemi@users.noreply.github.com>
Date: Fri, 12 Aug 2016 03:36:29 +0900
Subject: [PATCH 149/263] Remove tabs indent and redundant space. (#4343)

---
 src/main/java/rx/Scheduler.java | 178 ++++++++++++++++----------------
 1 file changed, 89 insertions(+), 89 deletions(-)

diff --git a/src/main/java/rx/Scheduler.java b/src/main/java/rx/Scheduler.java
index ee5f70ec46..405ceb3373 100644
--- a/src/main/java/rx/Scheduler.java
+++ b/src/main/java/rx/Scheduler.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -45,8 +45,8 @@ public abstract class Scheduler {
  *    maintenance.
  */
 
-    /** 
-     * The tolerance for a clock drift in nanoseconds where the periodic scheduler will rebase. 
+    /**
+     * The tolerance for a clock drift in nanoseconds where the periodic scheduler will rebase.
      * <p>
      * The associated system parameter, {@code rx.scheduler.drift-tolerance}, expects its value in minutes.
      */
@@ -55,14 +55,14 @@ public abstract class Scheduler {
         CLOCK_DRIFT_TOLERANCE_NANOS = TimeUnit.MINUTES.toNanos(
                 Long.getLong("rx.scheduler.drift-tolerance", 15));
     }
-    
+
     /**
      * Retrieves or creates a new {@link Scheduler.Worker} that represents serial execution of actions.
      * <p>
      * When work is completed it should be unsubscribed using {@link Scheduler.Worker#unsubscribe()}.
      * <p>
      * Work on a {@link Scheduler.Worker} is guaranteed to be sequential.
-     * 
+     *
      * @return a Worker representing a serial queue of actions to be executed
      */
     public abstract Worker createWorker();
@@ -76,7 +76,7 @@ public abstract static class Worker implements Subscription {
 
         /**
          * Schedules an Action for execution.
-         * 
+         *
          * @param action
          *            Action to schedule
          * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
@@ -107,7 +107,7 @@ public abstract static class Worker implements Subscription {
          * <p>
          * Note to implementors: non-positive {@code initialTime} and {@code period} should be regarded as
          * undelayed scheduling of the first and any subsequent executions.
-         * 
+         *
          * @param action
          *            the Action to execute periodically
          * @param initialDelay
@@ -127,7 +127,7 @@ public Subscription schedulePeriodically(final Action0 action, long initialDelay
 
             final SequentialSubscription first = new SequentialSubscription();
             final SequentialSubscription mas = new SequentialSubscription(first);
-            
+
             final Action0 recursiveAction = new Action0() {
                 long count;
                 long lastNowNanos = firstNowNanos;
@@ -137,9 +137,9 @@ public void call() {
                     action.call();
 
                     if (!mas.isUnsubscribed()) {
-                        
+
                         long nextTick;
-                        
+
                         long nowNanos = TimeUnit.MILLISECONDS.toNanos(now());
                         // If the clock moved in a direction quite a bit, rebase the repetition period
                         if (nowNanos + CLOCK_DRIFT_TOLERANCE_NANOS < lastNowNanos
@@ -154,7 +154,7 @@ public void call() {
                             nextTick = startInNanos + (++count * periodInNanos);
                         }
                         lastNowNanos = nowNanos;
-                        
+
                         long delay = nextTick - nowNanos;
                         mas.replace(schedule(this, delay, TimeUnit.NANOSECONDS));
                     }
@@ -183,82 +183,82 @@ public long now() {
         return System.currentTimeMillis();
     }
 
-	/**
-	 * Allows the use of operators for controlling the timing around when
-	 * actions scheduled on workers are actually done. This makes it possible to
-	 * layer additional behavior on this {@link Scheduler}. The only parameter
-	 * is a function that flattens an {@link Observable} of {@link Observable}
-	 * of {@link Completable}s into just one {@link Completable}. There must be
-	 * a chain of operators connecting the returned value to the source
-	 * {@link Observable} otherwise any work scheduled on the returned
-	 * {@link Scheduler} will not be executed.
-	 * <p>
-	 * When {@link Scheduler#createWorker()} is invoked a {@link Observable} of
-	 * {@link Completable}s is onNext'd to the combinator to be flattened. If
-	 * the inner {@link Observable} is not immediately subscribed to an calls to
-	 * {@link Worker#schedule} are buffered. Once the {@link Observable} is
-	 * subscribed to actions are then onNext'd as {@link Completable}s.
-	 * <p>
-	 * Finally the actions scheduled on the parent {@link Scheduler} when the
-	 * inner most {@link Completable}s are subscribed to.
-	 * <p>
-	 * When the {@link Worker} is unsubscribed the {@link Completable} emits an
-	 * onComplete and triggers any behavior in the flattening operator. The
-	 * {@link Observable} and all {@link Completable}s give to the flattening
-	 * function never onError.
-	 * <p>
-	 * Limit the amount concurrency two at a time without creating a new fix
-	 * size thread pool:
-	 * 
-	 * <pre>
-	 * Scheduler limitSched = Schedulers.computation().when(workers -> {
-	 * 	// use merge max concurrent to limit the number of concurrent
-	 * 	// callbacks two at a time
-	 * 	return Completable.merge(Observable.merge(workers), 2);
-	 * });
-	 * </pre>
-	 * <p>
-	 * This is a slightly different way to limit the concurrency but it has some
-	 * interesting benefits and drawbacks to the method above. It works by
-	 * limited the number of concurrent {@link Worker}s rather than individual
-	 * actions. Generally each {@link Observable} uses its own {@link Worker}.
-	 * This means that this will essentially limit the number of concurrent
-	 * subscribes. The danger comes from using operators like
-	 * {@link Observable#zip(Observable, Observable, rx.functions.Func2)} where
-	 * subscribing to the first {@link Observable} could deadlock the
-	 * subscription to the second.
-	 * 
-	 * <pre>
-	 * Scheduler limitSched = Schedulers.computation().when(workers -> {
-	 * 	// use merge max concurrent to limit the number of concurrent
-	 * 	// Observables two at a time
-	 * 	return Completable.merge(Observable.merge(workers, 2));
-	 * });
-	 * </pre>
-	 * 
-	 * Slowing down the rate to no more than than 1 a second. This suffers from
-	 * the same problem as the one above I could find an {@link Observable}
-	 * operator that limits the rate without dropping the values (aka leaky
-	 * bucket algorithm).
-	 * 
-	 * <pre>
-	 * Scheduler slowSched = Schedulers.computation().when(workers -> {
-	 * 	// use concatenate to make each worker happen one at a time.
-	 * 	return Completable.concat(workers.map(actions -> {
-	 * 		// delay the starting of the next worker by 1 second.
-	 * 		return Completable.merge(actions.delaySubscription(1, TimeUnit.SECONDS));
-	 * 	}));
-	 * });
-	 * </pre>
-	 * 
-	 * @param <S> a Scheduler and a Subscription
-	 * @param combine the function that takes a two-level nested Observable sequence of a Completable and returns
-	 * the Completable that will be subscribed to and should trigger the execution of the scheduled Actions.
-	 * @return the Scheduler with the customized execution behavior
-	 */
+    /**
+     * Allows the use of operators for controlling the timing around when
+     * actions scheduled on workers are actually done. This makes it possible to
+     * layer additional behavior on this {@link Scheduler}. The only parameter
+     * is a function that flattens an {@link Observable} of {@link Observable}
+     * of {@link Completable}s into just one {@link Completable}. There must be
+     * a chain of operators connecting the returned value to the source
+     * {@link Observable} otherwise any work scheduled on the returned
+     * {@link Scheduler} will not be executed.
+     * <p>
+     * When {@link Scheduler#createWorker()} is invoked a {@link Observable} of
+     * {@link Completable}s is onNext'd to the combinator to be flattened. If
+     * the inner {@link Observable} is not immediately subscribed to an calls to
+     * {@link Worker#schedule} are buffered. Once the {@link Observable} is
+     * subscribed to actions are then onNext'd as {@link Completable}s.
+     * <p>
+     * Finally the actions scheduled on the parent {@link Scheduler} when the
+     * inner most {@link Completable}s are subscribed to.
+     * <p>
+     * When the {@link Worker} is unsubscribed the {@link Completable} emits an
+     * onComplete and triggers any behavior in the flattening operator. The
+     * {@link Observable} and all {@link Completable}s give to the flattening
+     * function never onError.
+     * <p>
+     * Limit the amount concurrency two at a time without creating a new fix
+     * size thread pool:
+     *
+     * <pre>
+     * Scheduler limitSched = Schedulers.computation().when(workers -> {
+     * 	// use merge max concurrent to limit the number of concurrent
+     * 	// callbacks two at a time
+     * 	return Completable.merge(Observable.merge(workers), 2);
+     * });
+     * </pre>
+     * <p>
+     * This is a slightly different way to limit the concurrency but it has some
+     * interesting benefits and drawbacks to the method above. It works by
+     * limited the number of concurrent {@link Worker}s rather than individual
+     * actions. Generally each {@link Observable} uses its own {@link Worker}.
+     * This means that this will essentially limit the number of concurrent
+     * subscribes. The danger comes from using operators like
+     * {@link Observable#zip(Observable, Observable, rx.functions.Func2)} where
+     * subscribing to the first {@link Observable} could deadlock the
+     * subscription to the second.
+     *
+     * <pre>
+     * Scheduler limitSched = Schedulers.computation().when(workers -> {
+     * 	// use merge max concurrent to limit the number of concurrent
+     * 	// Observables two at a time
+     * 	return Completable.merge(Observable.merge(workers, 2));
+     * });
+     * </pre>
+     *
+     * Slowing down the rate to no more than than 1 a second. This suffers from
+     * the same problem as the one above I could find an {@link Observable}
+     * operator that limits the rate without dropping the values (aka leaky
+     * bucket algorithm).
+     *
+     * <pre>
+     * Scheduler slowSched = Schedulers.computation().when(workers -> {
+     * 	// use concatenate to make each worker happen one at a time.
+     * 	return Completable.concat(workers.map(actions -> {
+     * 		// delay the starting of the next worker by 1 second.
+     * 		return Completable.merge(actions.delaySubscription(1, TimeUnit.SECONDS));
+     *    }));
+     * });
+     * </pre>
+     *
+     * @param <S> a Scheduler and a Subscription
+     * @param combine the function that takes a two-level nested Observable sequence of a Completable and returns
+     * the Completable that will be subscribed to and should trigger the execution of the scheduled Actions.
+     * @return the Scheduler with the customized execution behavior
+     */
     @SuppressWarnings("unchecked")
     @Experimental
-	public <S extends Scheduler & Subscription> S when(Func1<Observable<Observable<Completable>>, Completable> combine) {
-		return (S) new SchedulerWhen(combine, this);
-	}
+    public <S extends Scheduler & Subscription> S when(Func1<Observable<Observable<Completable>>, Completable> combine) {
+        return (S) new SchedulerWhen(combine, this);
+    }
 }

From 72c051974e68dd08cb93019feacc777ebd98373c Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 12 Aug 2016 09:13:01 +0200
Subject: [PATCH 150/263] Release 1.1.9 update changes.md (#4345)

---
 CHANGES.md | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 1e911b3b10..745a0f83cd 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,44 @@
 # RxJava Releases #
 
+### Version 1.1.9 - August 12, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.9%7C))
+
+This release contains mostly internal cleanups, reinforced Observable-protocol adherence and minor javadoc fixes.
+
+**Warning**: the backpressure-behavior of `PublishSubject` has been changed. In earlier versions, when you called `PublishSubject.onNext` too frequently, that usually triggered a `MissingBackpressureException` in some downstream operator (`observeOn`, `zip`, etc.) and often it was not obvious who to blame for it. With 1.1.9, `PublishSubject` now tracks the request amounts of each of its children and refuses to overflow them, signalling a `MissingBackpressureException` to them instead which now points to the right operator.
+
+#### API enhancements
+
+  - [Pull 4226](https://github.com/ReactiveX/RxJava/pull/4226): Add `Single.flatMapCompletable`. 
+  - [Pull 4225](https://github.com/ReactiveX/RxJava/pull/4225): `PublishSubject` now signals `MissingBackpressureException` when backpressured.
+  - [Pull 4264](https://github.com/ReactiveX/RxJava/pull/4264): Add `Observable.sorted()` + overloads: sorts and re-emits each element of a finite sequence.
+  - [Pull 4261](https://github.com/ReactiveX/RxJava/pull/4261): Add `concatDelayError` multiple arguments.
+  - [Pull 4330](https://github.com/ReactiveX/RxJava/pull/4330): Add `Observable.concat(Iterable)` overload.
+  - [Pull 4322](https://github.com/ReactiveX/RxJava/pull/4322): Add `TestSubscriber.assertValuesAndClear` 
+
+#### Performance enhancements
+
+  - [Pull 4232](https://github.com/ReactiveX/RxJava/pull/4232): Less allocation in operator `amb`.
+  - [Pull 4233](https://github.com/ReactiveX/RxJava/pull/4233): Less allocation in `autoConnect`.
+  - [Pull 4236](https://github.com/ReactiveX/RxJava/pull/4236): Less allocation in `join`.
+  - [Pull 4237](https://github.com/ReactiveX/RxJava/pull/4237): Less allocation in `groupJoin` .
+  - [Pull 4239](https://github.com/ReactiveX/RxJava/pull/4239): Less allocation in `skip` with time.
+  - [Pull 4262](https://github.com/ReactiveX/RxJava/pull/4262): Less allocation in `doOnEach`. 
+  - [Pull 4328](https://github.com/ReactiveX/RxJava/pull/4328): Compact `MultipleAssignmentSubscription` and `SerialSubscription`
+
+#### Bugfixes
+
+  - [Pull 4231](https://github.com/ReactiveX/RxJava/pull/4213): `Schedulers.io()` workers now wait until a blocking task finishes before becoming available again.
+  - [Pull 4244](https://github.com/ReactiveX/RxJava/pull/4244): Fix `all` multiple terminal events.
+  - [Pull 4241](https://github.com/ReactiveX/RxJava/pull/4241): Fix reentrancy bug in `repeatWhen` and `retryWhen` when the resubscription happens.
+  - [Pull 4225](https://github.com/ReactiveX/RxJava/pull/4225): `PublishSubject` now checks for unsubscribed child while dispatching events.
+  - [Pull 4245](https://github.com/ReactiveX/RxJava/pull/4245): Fix `any` multiple terminal events.
+  - [Pull 4246](https://github.com/ReactiveX/RxJava/pull/4246): Fix `reduce` multiple terminal events.
+  - [Pull 4250](https://github.com/ReactiveX/RxJava/pull/4250): Fix `onBackpressureDrop` multiple terminal events.
+  - [Pull 4252](https://github.com/ReactiveX/RxJava/pull/4252): Fix `collect` multiple terminal events.
+  - [Pull 4251](https://github.com/ReactiveX/RxJava/pull/4251): Fix `toMap` multiple terminal events and backpressure behavior.
+  - [Pull 4270](https://github.com/ReactiveX/RxJava/pull/4270): Fix `toMultimap` multiple terminal events .
+  - [Pull 4311](https://github.com/ReactiveX/RxJava/pull/4311): Fix `Schedulers.from()` to call `RxJavaHooks.onScheduleAction`.
+  
 ### Version 1.1.8 - July 23, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.8%7C))
 
 #### Bugfixes

From a57741b5895d775e51753ebc5a67d26f400f49e3 Mon Sep 17 00:00:00 2001
From: Dimitar Asenov <dimitar.asenov@gmail.com>
Date: Tue, 16 Aug 2016 19:36:40 +0200
Subject: [PATCH 151/263] Add missing @Test annotation (#4359)

---
 src/test/java/rx/ObservableTests.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
index b3b6251778..121eb45ea9 100644
--- a/src/test/java/rx/ObservableTests.java
+++ b/src/test/java/rx/ObservableTests.java
@@ -152,6 +152,7 @@ public void call(Subscriber<? super String> obsv) {
         verify(w, times(1)).onError(any(RuntimeException.class));
     }
 
+    @Test
     public void testTakeFirstWithPredicateOfSome() {
         Observable<Integer> observable = Observable.just(1, 3, 5, 4, 6, 3);
         observable.takeFirst(IS_EVEN).subscribe(w);

From 1a7de42630959085d9bd89d039dce51c02a4214a Mon Sep 17 00:00:00 2001
From: Jake Wharton <jakewharton@gmail.com>
Date: Sun, 21 Aug 2016 04:41:53 -0400
Subject: [PATCH 152/263] Remove explicit StackOverflow check as its a
 VirtualMachineError. (#4390)

Looks like [the linked comment][1] was misinterpreted (but not in a way that affected the implementation) as Scala considered StackOverflowError as non-fatal but RxJava always considered it fatal. As such, its explicit check was redundant.

 [1]: https://github.com/ReactiveX/RxJava/issues/748#issuecomment-32471495
---
 src/main/java/rx/exceptions/Exceptions.java | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/main/java/rx/exceptions/Exceptions.java b/src/main/java/rx/exceptions/Exceptions.java
index 1486012d2d..de36d5e134 100644
--- a/src/main/java/rx/exceptions/Exceptions.java
+++ b/src/main/java/rx/exceptions/Exceptions.java
@@ -65,7 +65,6 @@ public static RuntimeException propagate(Throwable t) {
      * <li>{@link OnErrorNotImplementedException}</li>
      * <li>{@link OnErrorFailedException}</li>
      * <li>{@link OnCompletedFailedException}</li>
-     * <li>{@code StackOverflowError}</li>
      * <li>{@code VirtualMachineError}</li>
      * <li>{@code ThreadDeath}</li>
      * <li>{@code LinkageError}</li>
@@ -88,9 +87,7 @@ public static void throwIfFatal(Throwable t) {
             throw (OnCompletedFailedException) t;
         }
         // values here derived from https://github.com/ReactiveX/RxJava/issues/748#issuecomment-32471495
-        else if (t instanceof StackOverflowError) {
-            throw (StackOverflowError) t;
-        } else if (t instanceof VirtualMachineError) {
+        else if (t instanceof VirtualMachineError) {
             throw (VirtualMachineError) t;
         } else if (t instanceof ThreadDeath) {
             throw (ThreadDeath) t;

From 3aaed2673d3732f8c6c015c04576cbb9491cb72b Mon Sep 17 00:00:00 2001
From: Anton Rutkevich <AntonRutkevich@users.noreply.github.com>
Date: Sun, 21 Aug 2016 18:27:43 +0300
Subject: [PATCH 153/263] 1.x: Fix multiple values produced by throttleFirst
 with TestScheduler (#4397)

When throttleFirst was operating on a TestScheduler, it delivered all items passed to it untill TestScheduler's time would change to a non-zero value.
---
 .../operators/OperatorThrottleFirst.java      |  4 +-
 .../operators/OperatorThrottleFirstTest.java  | 42 +++++++++++++++++++
 2 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorThrottleFirst.java b/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
index b7a368578b..d41f3262eb 100644
--- a/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
+++ b/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
@@ -38,7 +38,7 @@ public OperatorThrottleFirst(long windowDuration, TimeUnit unit, Scheduler sched
     public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
         return new Subscriber<T>(subscriber) {
 
-            private long lastOnNext;
+            private long lastOnNext = -1;
 
             @Override
             public void onStart() {
@@ -48,7 +48,7 @@ public void onStart() {
             @Override
             public void onNext(T v) {
                 long now = scheduler.now();
-                if (lastOnNext == 0 || now - lastOnNext >= timeInMilliseconds) {
+                if (lastOnNext == -1 || now - lastOnNext >= timeInMilliseconds) {
                     lastOnNext = now;
                     subscriber.onNext(v);
                 } 
diff --git a/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java b/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
index e2f7374753..7bab85cd1d 100644
--- a/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
+++ b/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
@@ -19,6 +19,8 @@
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 import java.util.concurrent.TimeUnit;
 
@@ -172,4 +174,44 @@ public void timed() {
         ts.assertNoErrors();
         ts.assertCompleted();
     }
+
+    @Test
+    public void throttleWithoutAdvancingTimeOfTestScheduler() {
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = mock(Observer.class);
+        TestScheduler s = new TestScheduler();
+        PublishSubject<Integer> o = PublishSubject.create();
+        o.throttleFirst(500, TimeUnit.MILLISECONDS, s).subscribe(observer);
+
+        // send events without calling advanceTimeBy/To
+        o.onNext(1); // deliver
+        o.onNext(2); // skip
+        o.onNext(3); // skip
+        o.onCompleted();
+
+        verify(observer).onNext(1);
+        verify(observer).onCompleted();
+        verifyNoMoreInteractions(observer);
+    }
+
+    @Test
+    public void throttleWithTestSchedulerTimeOfZero() {
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = mock(Observer.class);
+        TestScheduler s = new TestScheduler();
+        PublishSubject<Integer> o = PublishSubject.create();
+        o.throttleFirst(500, TimeUnit.MILLISECONDS, s).subscribe(observer);
+
+        s.advanceTimeBy(0, TimeUnit.MILLISECONDS);
+
+        // send events while TestScheduler's time is 0
+        o.onNext(1); // deliver
+        o.onNext(2); // skip
+        o.onNext(3); // skip
+        o.onCompleted();
+
+        verify(observer).onNext(1);
+        verify(observer).onCompleted();
+        verifyNoMoreInteractions(observer);
+    }
 }

From a5c945399ff7325d91d109b607fe6406a27ca838 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Wed, 24 Aug 2016 11:34:04 +0200
Subject: [PATCH 154/263] 1.x: Sync doOnEach java doc (#4418)

---
 src/main/java/rx/Observable.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index f17ab86dc2..fc928b3c46 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -5803,7 +5803,7 @@ public final Observable<T> doOnCompleted(final Action0 onCompleted) {
     }
 
     /**
-     * Modifies the source Observable so that it invokes an action for each item it emits.
+     * Modifies the source Observable so that it invokes an action for each item and terminal event it emits.
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/doOnEach.png" alt="">
      * <dl>

From 743f164b1b2f20ed34ae97a48872a0c548375911 Mon Sep 17 00:00:00 2001
From: Jake Wharton <jakewharton@gmail.com>
Date: Thu, 25 Aug 2016 03:51:18 -0400
Subject: [PATCH 155/263] Add to() conversion function to all stream types.
 (#4423)

This deprecates extend() on Observable, which is a less powerful version of these functions.
---
 src/main/java/rx/Completable.java     | 13 +++++++------
 src/main/java/rx/Observable.java      | 15 ++++++++++++++-
 src/main/java/rx/Single.java          | 13 +++++++++++++
 src/test/java/rx/CompletableTest.java | 17 +++++++++++++++++
 src/test/java/rx/ObservableTests.java | 17 +++++++++++++++++
 src/test/java/rx/SingleTest.java      | 17 +++++++++++++++++
 6 files changed, 85 insertions(+), 7 deletions(-)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 6848ea05bb..ab466463ed 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -2222,13 +2222,14 @@ public final Completable timeout0(long timeout, TimeUnit unit, Scheduler schedul
     }
     
     /**
-     * Allows fluent conversion to another type via a function callback.
-     * @param <U> the output type as determined by the converter function
-     * @param converter the function called with this which should return some other value.
-     * @return the converted value
-     * @throws NullPointerException if converter is null
+     * Calls the specified converter function during assembly time and returns its resulting value.
+     * <p>
+     * This allows fluent conversion to any other type.
+     * @param <R> the resulting object type
+     * @param converter the function that receives the current Single instance and returns a value
+     * @return the value returned by the function
      */
-    public final <U> U to(Func1<? super Completable, U> converter) {
+    public final <R> R to(Func1<? super Completable, R> converter) {
         return converter.call(this);
     }
 
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index fc928b3c46..ed83037e07 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -212,7 +212,7 @@ public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<
      * @return an instance of R created by the provided conversion function
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Experimental @Deprecated // TODO remove method some time after 1.2.0 release. It was never a stable API.
     public <R> R extend(Func1<? super OnSubscribe<T>, ? extends R> conversion) {
         return conversion.call(new OnSubscribeExtend<T>(this));
     }
@@ -309,6 +309,19 @@ public interface Transformer<T, R> extends Func1<Observable<T>, Observable<R>> {
         // cover for generics insanity
     }
 
+    /**
+     * Calls the specified converter function during assembly time and returns its resulting value.
+     * <p>
+     * This allows fluent conversion to any other type.
+     * @param <R> the resulting object type
+     * @param converter the function that receives the current Observable instance and returns a value
+     * @return the value returned by the function
+     */
+    @Experimental
+    public final <R> R to(Func1<? super Observable<T>, R> converter) {
+        return converter.call(this);
+    }
+
     /**
      * Returns a Single that emits the single item emitted by the source Observable, if that Observable
      * emits only a single item. If the source Observable emits more than one item or no items, notify of an
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 198dba876c..bec23882ba 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -2197,6 +2197,19 @@ public void onError(Throwable e) {
             }
         });
     }
+
+    /**
+     * Calls the specified converter function during assembly time and returns its resulting value.
+     * <p>
+     * This allows fluent conversion to any other type.
+     * @param <R> the resulting object type
+     * @param converter the function that receives the current Single instance and returns a value
+     * @return the value returned by the function
+     */
+    @Experimental
+    public final <R> R to(Func1<? super Single<T>, R> converter) {
+        return converter.call(this);
+    }
     
     /**
      * Converts this Single into an {@link Observable}.
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 6545cafeef..6ae30f4293 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -4158,4 +4158,21 @@ public Boolean call(Throwable t) {
         Assert.assertTrue(errors.get(1).toString(), errors.get(1) instanceof TestException);
         Assert.assertEquals(errors.get(1).toString(), "Forced inner failure", errors.get(1).getMessage());
     }
+
+    @Test public void toFunctionReceivesObservableReturnsResult() {
+        Completable c = Completable.error(new RuntimeException());
+
+        final Object expectedResult = new Object();
+        final AtomicReference<Completable> completableRef = new AtomicReference<Completable>();
+        Object actualResult = c.to(new Func1<Completable, Object>() {
+            @Override
+            public Object call(Completable completable) {
+                completableRef.set(completable);
+                return expectedResult;
+            }
+        });
+
+        assertSame(expectedResult, actualResult);
+        assertSame(c, completableRef.get());
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
index 121eb45ea9..16443d4476 100644
--- a/src/test/java/rx/ObservableTests.java
+++ b/src/test/java/rx/ObservableTests.java
@@ -1423,4 +1423,21 @@ public void call() {
         assertTrue(list.get(1).toString(), list.get(1) instanceof TestException);
         assertEquals(100, list.get(2));
     }
+
+    @Test public void toFunctionReceivesObservableReturnsResult() {
+        Observable<String> o = Observable.just("Hi");
+
+        final Object expectedResult = new Object();
+        final AtomicReference<Observable<?>> observableRef = new AtomicReference<Observable<?>>();
+        Object actualResult = o.to(new Func1<Observable<String>, Object>() {
+            @Override
+            public Object call(Observable<String> observable) {
+                observableRef.set(observable);
+                return expectedResult;
+            }
+        });
+
+        assertSame(expectedResult, actualResult);
+        assertSame(o, observableRef.get());
+    }
 }
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index acc95c6ef6..fa68df8a16 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -2069,4 +2069,21 @@ public Completable call(final Integer integer) {
 
         testSubscriber.assertError(UnsupportedOperationException.class);
     }
+
+    @Test public void toFunctionReceivesObservableReturnsResult() {
+        Single<String> s = Single.just("Hi");
+
+        final Object expectedResult = new Object();
+        final AtomicReference<Single<?>> singleRef = new AtomicReference<Single<?>>();
+        Object actualResult = s.to(new Func1<Single<String>, Object>() {
+            @Override
+            public Object call(Single<String> single) {
+                singleRef.set(single);
+                return expectedResult;
+            }
+        });
+
+        assertSame(expectedResult, actualResult);
+        assertSame(s, singleRef.get());
+    }
 }

From 5ac4d2aed5d8ed93c6835e26ddfb0f0b944d5c89 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Fri, 26 Aug 2016 16:41:31 +1000
Subject: [PATCH 156/263] fromAsync - handle post-terminal events (#4427)

---
 .../operators/OnSubscribeFromAsync.java       | 35 ++++++++-
 .../operators/OnSubscribeFromAsyncTest.java   | 76 +++++++++++++++++++
 2 files changed, 110 insertions(+), 1 deletion(-)

diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromAsync.java b/src/main/java/rx/internal/operators/OnSubscribeFromAsync.java
index 1aa42954a1..b5d57b8135 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromAsync.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromAsync.java
@@ -223,7 +223,7 @@ public NoOverflowBaseAsyncEmitter(Subscriber<? super T> actual) {
         }
 
         @Override
-        public final void onNext(T t) {
+        public void onNext(T t) {
             if (actual.isUnsubscribed()) {
                 return;
             }
@@ -259,10 +259,43 @@ static final class ErrorAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
 
         /** */
         private static final long serialVersionUID = 338953216916120960L;
+        
+        private boolean done;
 
         public ErrorAsyncEmitter(Subscriber<? super T> actual) {
             super(actual);
         }
+        
+
+        @Override
+        public void onNext(T t) {
+            if (done) {
+                return;
+            }
+            super.onNext(t);
+        }
+
+
+        @Override
+        public void onCompleted() {
+            if (done) {
+                return;
+            }
+            done = true;
+            super.onCompleted();
+        }
+
+
+        @Override
+        public void onError(Throwable e) {
+            if (done) {
+                RxJavaHooks.onError(e);
+                return;
+            }
+            done = true;
+            super.onError(e);
+        }
+
 
         @Override
         void onOverflow() {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromAsyncTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromAsyncTest.java
index 26dd1f75f6..bc6587ac0d 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromAsyncTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromAsyncTest.java
@@ -16,12 +16,19 @@
 
 package rx.internal.operators;
 
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
 import org.junit.*;
 
 import rx.*;
 import rx.exceptions.*;
 import rx.functions.Action1;
 import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
 import rx.subjects.PublishSubject;
 
 public class OnSubscribeFromAsyncTest {
@@ -134,6 +141,75 @@ public void normalError() {
         
         Assert.assertEquals("fromAsync: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
     }
+    
+    @Test
+    public void overflowErrorIsNotFollowedByAnotherErrorDueToOnNextFromUpstream() {
+        Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
+
+            @Override
+            public void call(AsyncEmitter<Integer> emitter) {
+                emitter.onNext(1);
+                //don't check for unsubscription
+                emitter.onNext(2);
+            }};
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(MissingBackpressureException.class);
+        ts.assertNotCompleted();
+        
+        Assert.assertEquals("fromAsync: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+    }
+    
+    @Test
+    public void overflowErrorIsNotFollowedByAnotherCompletedDueToCompletedFromUpstream() {
+        Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
+
+            @Override
+            public void call(AsyncEmitter<Integer> emitter) {
+                emitter.onNext(1);
+                //don't check for unsubscription
+                emitter.onCompleted();
+            }};
+        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(MissingBackpressureException.class);
+        ts.assertNotCompleted();
+        
+        Assert.assertEquals("fromAsync: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+    }
+    
+    @Test
+    public void overflowErrorIsNotFollowedByAnotherErrorDueToOnErrorFromUpstreamAndSecondErrorIsReportedToHook() {
+        try {
+            final List<Throwable> list = new CopyOnWriteArrayList<Throwable>();
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+                @Override
+                public void call(Throwable t) {
+                    list.add(t);
+                }});
+            final RuntimeException e = new RuntimeException();
+            Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
+    
+                @Override
+                public void call(AsyncEmitter<Integer> emitter) {
+                    emitter.onNext(1);
+                    //don't check for unsubscription
+                    emitter.onError(e);
+                }};
+            Observable.fromAsync(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+            
+            ts.assertNoValues();
+            ts.assertError(MissingBackpressureException.class);
+            ts.assertNotCompleted();
+            
+            Assert.assertEquals("fromAsync: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+            assertEquals(Arrays.asList(e), list);
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
 
     @Test
     public void errorBuffered() {

From c25804881c52ba202ffe6348c0cd7e166202473b Mon Sep 17 00:00:00 2001
From: Shintaro Katafuchi <hotchemi@users.noreply.github.com>
Date: Sun, 28 Aug 2016 02:20:58 +0900
Subject: [PATCH 157/263] Fix typo. (#4432)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index fc35e066d8..3525242ea4 100644
--- a/README.md
+++ b/README.md
@@ -102,7 +102,7 @@ $ cd RxJava/
 $ ./gradlew build
 ```
 
-Futher details on building can be found on the [Getting Started](https://github.com/ReactiveX/RxJava/wiki/Getting-Started) page of the wiki.
+Further details on building can be found on the [Getting Started](https://github.com/ReactiveX/RxJava/wiki/Getting-Started) page of the wiki.
 
 ## Bugs and Feedback
 

From db3ff46c7ad37cca4224f07d517f108357201220 Mon Sep 17 00:00:00 2001
From: Jake Wharton <jakewharton@gmail.com>
Date: Tue, 30 Aug 2016 03:12:49 -0400
Subject: [PATCH 158/263] Remove 'Completable' prefix from nested interfaces,
 move its subscription to top-level. (#4425)

---
 src/main/java/rx/Completable.java             | 284 +++++++++++++-----
 src/main/java/rx/CompletableSubscriber.java   |  42 +++
 src/main/java/rx/Single.java                  |   2 +-
 ...CompletableFlatMapSingleToCompletable.java |   6 +-
 .../CompletableOnSubscribeConcat.java         |   4 +-
 .../CompletableOnSubscribeConcatArray.java    |   4 +-
 .../CompletableOnSubscribeConcatIterable.java |   4 +-
 .../CompletableOnSubscribeMerge.java          |   4 +-
 .../CompletableOnSubscribeMergeArray.java     |   4 +-
 ...etableOnSubscribeMergeDelayErrorArray.java |   4 +-
 ...bleOnSubscribeMergeDelayErrorIterable.java |   4 +-
 .../CompletableOnSubscribeMergeIterable.java  |   4 +-
 .../CompletableOnSubscribeTimeout.java        |   4 +-
 .../OnSubscribeOnAssemblyCompletable.java     |  10 +-
 .../rx/internal/schedulers/SchedulerWhen.java |   7 +-
 .../observers/AsyncCompletableSubscriber.java |   2 +-
 .../observers/SafeCompletableSubscriber.java  |   2 +-
 .../RxJavaCompletableExecutionHook.java       |  22 +-
 src/main/java/rx/plugins/RxJavaHooks.java     |  96 +++---
 src/test/java/rx/CompletableTest.java         |  49 ++-
 .../observers/CompletableSubscriberTest.java  |   2 +-
 src/test/java/rx/plugins/RxJavaHooksTest.java |  66 ++--
 22 files changed, 393 insertions(+), 233 deletions(-)
 create mode 100644 src/main/java/rx/CompletableSubscriber.java

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index ab466463ed..474c6e7cdf 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -20,7 +20,6 @@
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import rx.Observable.OnSubscribe;
 import rx.annotations.Experimental;
 import rx.exceptions.*;
 import rx.functions.*;
@@ -39,25 +38,62 @@
 @Experimental
 public class Completable {
     /** The actual subscription action. */
-    private final CompletableOnSubscribe onSubscribe;
+    private final OnSubscribe onSubscribe;
+    
     /**
-     * Callback used for building deferred computations that takes a CompletableSubscriber.
+     * @deprecated Use {@link OnSubscribe} instead.
      */
+    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
     public interface CompletableOnSubscribe extends Action1<CompletableSubscriber> {
+
+    }
+
+    private static OnSubscribe fromOldOnSubscribe(final CompletableOnSubscribe onSubscribe) {
+        return new OnSubscribe() {
+            @Override
+            public void call(final rx.CompletableSubscriber s) {
+                onSubscribe.call(toOldSubscriber(s));
+            }
+        };
+    }
+
+    /**
+     * Callback used for building deferred computations that takes a CompletableSubscriber.
+     */
+    public interface OnSubscribe extends Action1<rx.CompletableSubscriber> {
         
     }
+
+    /**
+     * @deprecated Use {@link Operator} instead.
+     */
+    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
+    public interface CompletableOperator extends Func1<CompletableSubscriber, CompletableSubscriber> {
+
+    }
+
+    private static Operator fromOldOperator(final CompletableOperator operator) {
+        requireNonNull(operator);
+        return new Operator() {
+            @Override
+            public rx.CompletableSubscriber call(final rx.CompletableSubscriber subscriber) {
+                return fromOldSubscriber(operator.call(toOldSubscriber(subscriber)));
+            }
+        };
+    }
     
     /**
      * Convenience interface and callback used by the lift operator that given a child CompletableSubscriber,
      * return a parent CompletableSubscriber that does any kind of lifecycle-related transformations.
      */
-    public interface CompletableOperator extends Func1<CompletableSubscriber, CompletableSubscriber> {
+    public interface Operator extends Func1<rx.CompletableSubscriber, rx.CompletableSubscriber> {
         
     }
     
     /**
-     * Represents the subscription API callbacks when subscribing to a Completable instance.
+     * @deprecated Use {@link rx.CompletableSubscriber} instead.
      */
+    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
     public interface CompletableSubscriber {
         /**
          * Called once the deferred computation completes normally.
@@ -78,27 +114,75 @@ public interface CompletableSubscriber {
         void onSubscribe(Subscription d);
     }
     
+    static rx.CompletableSubscriber fromOldSubscriber(final CompletableSubscriber subscriber) {
+        requireNonNull(subscriber);
+        return new rx.CompletableSubscriber() {
+            @Override
+            public void onCompleted() {
+                subscriber.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+
+            @Override
+            public void onSubscribe(Subscription d) {
+                subscriber.onSubscribe(d);
+            }
+        };
+    }
+
+    static CompletableSubscriber toOldSubscriber(final rx.CompletableSubscriber subscriber) {
+        requireNonNull(subscriber);
+        return new CompletableSubscriber() {
+            @Override
+            public void onCompleted() {
+                subscriber.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+
+            @Override
+            public void onSubscribe(Subscription d) {
+                subscriber.onSubscribe(d);
+            }
+        };
+    }
+
+    /**
+     * @deprecated Use {@link Transformer} instead.
+     */
+    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
+    public interface CompletableTransformer extends Transformer {
+
+    }
+
     /**
      * Convenience interface and callback used by the compose operator to turn a Completable into another
      * Completable fluently.
      */
-    public interface CompletableTransformer extends Func1<Completable, Completable> {
+    public interface Transformer extends Func1<Completable, Completable> {
         
     }
     
     /** Single instance of a complete Completable. */
-    static final Completable COMPLETE = new Completable(new CompletableOnSubscribe() {
+    static final Completable COMPLETE = new Completable(new OnSubscribe() {
         @Override
-        public void call(CompletableSubscriber s) {
+        public void call(rx.CompletableSubscriber s) {
             s.onSubscribe(Subscriptions.unsubscribed());
             s.onCompleted();
         }
     }, false); // hook is handled in complete()
     
     /** Single instance of a never Completable. */
-    static final Completable NEVER = new Completable(new CompletableOnSubscribe() {
+    static final Completable NEVER = new Completable(new OnSubscribe() {
         @Override
-        public void call(CompletableSubscriber s) {
+        public void call(rx.CompletableSubscriber s) {
             s.onSubscribe(Subscriptions.unsubscribed());
         }
     }, false); // hook is handled in never()
@@ -119,15 +203,15 @@ public static Completable amb(final Completable... sources) {
             return sources[0];
         }
         
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
+            public void call(final rx.CompletableSubscriber s) {
                 final CompositeSubscription set = new CompositeSubscription();
                 s.onSubscribe(set);
 
                 final AtomicBoolean once = new AtomicBoolean();
                 
-                CompletableSubscriber inner = new CompletableSubscriber() {
+                rx.CompletableSubscriber inner = new rx.CompletableSubscriber() {
                     @Override
                     public void onCompleted() {
                         if (once.compareAndSet(false, true)) {
@@ -188,9 +272,9 @@ public void onSubscribe(Subscription d) {
     public static Completable amb(final Iterable<? extends Completable> sources) {
         requireNonNull(sources);
         
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
+            public void call(final rx.CompletableSubscriber s) {
                 final CompositeSubscription set = new CompositeSubscription();
                 s.onSubscribe(set);
 
@@ -212,7 +296,7 @@ public void call(final CompletableSubscriber s) {
                 
                 final AtomicBoolean once = new AtomicBoolean();
                 
-                CompletableSubscriber inner = new CompletableSubscriber() {
+                rx.CompletableSubscriber inner = new rx.CompletableSubscriber() {
                     @Override
                     public void onCompleted() {
                         if (once.compareAndSet(false, true)) {
@@ -311,7 +395,7 @@ public void onSubscribe(Subscription d) {
      * @return a Completable instance that completes immediately 
      */
     public static Completable complete() {
-        CompletableOnSubscribe cos = RxJavaHooks.onCreate(COMPLETE.onSubscribe);
+        OnSubscribe cos = RxJavaHooks.onCreate(COMPLETE.onSubscribe);
         if (cos == COMPLETE.onSubscribe) {
             return COMPLETE;
         }
@@ -371,6 +455,14 @@ public static Completable concat(Observable<? extends Completable> sources, int
         }
         return create(new CompletableOnSubscribeConcat(sources, prefetch));
     }
+
+    /**
+     * @deprecated Use {@link #create(OnSubscribe)}.
+     */
+    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
+    public static Completable create(CompletableOnSubscribe onSubscribe) {
+        return create(fromOldOnSubscribe(onSubscribe));
+    }
     
     /**
      * Constructs a Completable instance by wrapping the given onSubscribe callback.
@@ -379,7 +471,7 @@ public static Completable concat(Observable<? extends Completable> sources, int
      * @return the created Completable instance
      * @throws NullPointerException if onSubscribe is null
      */
-    public static Completable create(CompletableOnSubscribe onSubscribe) {
+    public static Completable create(OnSubscribe onSubscribe) {
         requireNonNull(onSubscribe);
         try {
             return new Completable(onSubscribe);
@@ -398,9 +490,9 @@ public static Completable create(CompletableOnSubscribe onSubscribe) {
      */
     public static Completable defer(final Func0<? extends Completable> completableFunc0) {
         requireNonNull(completableFunc0);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(CompletableSubscriber s) {
+            public void call(rx.CompletableSubscriber s) {
                 Completable c;
                 
                 try {
@@ -434,9 +526,9 @@ public void call(CompletableSubscriber s) {
      */
     public static Completable error(final Func0<? extends Throwable> errorFunc0) {
         requireNonNull(errorFunc0);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(CompletableSubscriber s) {
+            public void call(rx.CompletableSubscriber s) {
                 s.onSubscribe(Subscriptions.unsubscribed());
                 Throwable error;
                 
@@ -462,9 +554,9 @@ public void call(CompletableSubscriber s) {
      */
     public static Completable error(final Throwable error) {
         requireNonNull(error);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(CompletableSubscriber s) {
+            public void call(rx.CompletableSubscriber s) {
                 s.onSubscribe(Subscriptions.unsubscribed());
                 s.onError(error);
             }
@@ -480,9 +572,9 @@ public void call(CompletableSubscriber s) {
      */
     public static Completable fromAction(final Action0 action) {
         requireNonNull(action);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(CompletableSubscriber s) {
+            public void call(rx.CompletableSubscriber s) {
                 BooleanSubscription bs = new BooleanSubscription();
                 s.onSubscribe(bs);
                 try {
@@ -508,9 +600,9 @@ public void call(CompletableSubscriber s) {
      */
     public static Completable fromCallable(final Callable<?> callable) {
         requireNonNull(callable);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(CompletableSubscriber s) {
+            public void call(rx.CompletableSubscriber s) {
                 BooleanSubscription bs = new BooleanSubscription();
                 s.onSubscribe(bs);
                 try {
@@ -549,9 +641,9 @@ public static Completable fromFuture(Future<?> future) {
      */
     public static Completable fromObservable(final Observable<?> flowable) {
         requireNonNull(flowable);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber cs) {
+            public void call(final rx.CompletableSubscriber cs) {
                 Subscriber<Object> subscriber = new Subscriber<Object>() {
 
                     @Override
@@ -584,9 +676,9 @@ public void onNext(Object t) {
      */
     public static Completable fromSingle(final Single<?> single) {
         requireNonNull(single);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
+            public void call(final rx.CompletableSubscriber s) {
                 SingleSubscriber<Object> te = new SingleSubscriber<Object>() {
 
                     @Override
@@ -738,7 +830,7 @@ public static Completable mergeDelayError(Observable<? extends Completable> sour
      * @return the singleton instance that never calls onError or onComplete
      */
     public static Completable never() {
-        CompletableOnSubscribe cos = RxJavaHooks.onCreate(NEVER.onSubscribe);
+        OnSubscribe cos = RxJavaHooks.onCreate(NEVER.onSubscribe);
         if (cos == NEVER.onSubscribe) {
             return NEVER;
         }
@@ -779,9 +871,9 @@ public static Completable timer(long delay, TimeUnit unit) {
     public static Completable timer(final long delay, final TimeUnit unit, final Scheduler scheduler) {
         requireNonNull(unit);
         requireNonNull(scheduler);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
+            public void call(final rx.CompletableSubscriber s) {
                 MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
                 s.onSubscribe(mad);
                 if (!mad.isUnsubscribed()) {
@@ -856,9 +948,9 @@ public static <R> Completable using(final Func0<R> resourceFunc0,
         requireNonNull(completableFunc1);
         requireNonNull(disposer);
         
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
+            public void call(final rx.CompletableSubscriber s) {
                 final R resource; // NOPMD 
                 
                 try {
@@ -908,7 +1000,7 @@ public void call(final CompletableSubscriber s) {
                 
                 final AtomicBoolean once = new AtomicBoolean();
                 
-                cs.unsafeSubscribe(new CompletableSubscriber() {
+                cs.unsafeSubscribe(new rx.CompletableSubscriber() {
                     Subscription d;
                     void dispose() {
                         d.unsubscribe();
@@ -980,10 +1072,18 @@ public void call() {
      * @param onSubscribe the callback that will receive CompletableSubscribers when they subscribe,
      * not null (not verified)
      */
-    protected Completable(CompletableOnSubscribe onSubscribe) {
+    protected Completable(OnSubscribe onSubscribe) {
         this.onSubscribe = RxJavaHooks.onCreate(onSubscribe);
     }
 
+    /**
+     * @deprecated Use {@link #Completable(OnSubscribe)}.
+     */
+    @Deprecated // TODO Remove constructor after 1.2.0 release. It was never a stable API. Provided only for migration.
+    protected Completable(CompletableOnSubscribe onSubscribe) {
+        this(fromOldOnSubscribe(onSubscribe));
+    }
+
     /**
      * Constructs a Completable instance with the given onSubscribe callback without calling the onCreate
      * hook.
@@ -991,10 +1091,18 @@ protected Completable(CompletableOnSubscribe onSubscribe) {
      * not null (not verified)
      * @param useHook if false, RxJavaHooks.onCreate won't be called
      */
-    private Completable(CompletableOnSubscribe onSubscribe, boolean useHook) {
+    private Completable(OnSubscribe onSubscribe, boolean useHook) {
         this.onSubscribe = useHook ? RxJavaHooks.onCreate(onSubscribe) : onSubscribe;
     }
 
+    /**
+     * @deprecated Use {@link #Completable(OnSubscribe, boolean)}.
+     */
+    @Deprecated // TODO Remove constructor after 1.2.0 release. It was never a stable API. Provided only for migration.
+    protected Completable(CompletableOnSubscribe onSubscribe, boolean useHook) {
+        this(fromOldOnSubscribe(onSubscribe), useHook);
+    }
+
     /**
      * Returns a Completable that emits the a terminated event of either this Completable
      * or the other Completable whichever fires first.
@@ -1016,7 +1124,7 @@ public final void await() {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
         
-        unsafeSubscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new rx.CompletableSubscriber() {
 
             @Override
             public void onCompleted() {
@@ -1067,7 +1175,7 @@ public final boolean await(long timeout, TimeUnit unit) {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
         
-        unsafeSubscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new rx.CompletableSubscriber() {
 
             @Override
             public void onCompleted() {
@@ -1114,7 +1222,7 @@ public void onSubscribe(Subscription d) {
      * @return the Completable returned by the function
      * @throws NullPointerException if transformer is null
      */
-    public final Completable compose(CompletableTransformer transformer) {
+    public final Completable compose(Transformer transformer) {
         return to(transformer);
     }
     
@@ -1214,15 +1322,15 @@ public final Completable delay(long delay, TimeUnit unit, Scheduler scheduler) {
     public final Completable delay(final long delay, final TimeUnit unit, final Scheduler scheduler, final boolean delayError) {
         requireNonNull(unit);
         requireNonNull(scheduler);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
+            public void call(final rx.CompletableSubscriber s) {
                 final CompositeSubscription set = new CompositeSubscription();
                 
                 final Scheduler.Worker w = scheduler.createWorker();
                 set.add(w);
                 
-                unsafeSubscribe(new CompletableSubscriber() {
+                unsafeSubscribe(new rx.CompletableSubscriber() {
 
                     
                     @Override
@@ -1331,10 +1439,10 @@ protected final Completable doOnLifecycle(
         requireNonNull(onComplete);
         requireNonNull(onAfterComplete);
         requireNonNull(onUnsubscribe);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
-                unsafeSubscribe(new CompletableSubscriber() {
+            public void call(final rx.CompletableSubscriber s) {
+                unsafeSubscribe(new rx.CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
@@ -1470,7 +1578,7 @@ public final Throwable get() {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
         
-        unsafeSubscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new rx.CompletableSubscriber() {
 
             @Override
             public void onCompleted() {
@@ -1516,7 +1624,7 @@ public final Throwable get(long timeout, TimeUnit unit) {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
         
-        unsafeSubscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new rx.CompletableSubscriber() {
 
             @Override
             public void onCompleted() {
@@ -1551,6 +1659,14 @@ public void onSubscribe(Subscription d) {
         Exceptions.propagate(new TimeoutException());
         return null;
     }
+
+    /**
+     * @deprecated Use {@link #lift(Operator)}.
+     */
+    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
+    public final Completable lift(CompletableOperator onLift) {
+        return lift(fromOldOperator(onLift));
+    }
     
     /**
      * Lifts a CompletableSubscriber transformation into the chain of Completables.
@@ -1558,14 +1674,14 @@ public void onSubscribe(Subscription d) {
      * @return the new Completable instance
      * @throws NullPointerException if onLift is null
      */
-    public final Completable lift(final CompletableOperator onLift) {
+    public final Completable lift(final Operator onLift) {
         requireNonNull(onLift);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(CompletableSubscriber s) {
+            public void call(rx.CompletableSubscriber s) {
                 try {
-                    CompletableOperator onLiftDecorated = RxJavaHooks.onCompletableLift(onLift);
-                    CompletableSubscriber sw = onLiftDecorated.call(s);
+                    Operator onLiftDecorated = RxJavaHooks.onCompletableLift(onLift);
+                    rx.CompletableSubscriber sw = onLiftDecorated.call(s);
                     
                     unsafeSubscribe(sw);
                 } catch (NullPointerException ex) { // NOPMD 
@@ -1597,9 +1713,9 @@ public final Completable mergeWith(Completable other) {
      */
     public final Completable observeOn(final Scheduler scheduler) {
         requireNonNull(scheduler);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
+            public void call(final rx.CompletableSubscriber s) {
                 
                 final SubscriptionList ad = new SubscriptionList();
                 
@@ -1608,7 +1724,7 @@ public void call(final CompletableSubscriber s) {
                 
                 s.onSubscribe(ad);
                 
-                unsafeSubscribe(new CompletableSubscriber() {
+                unsafeSubscribe(new rx.CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
@@ -1667,10 +1783,10 @@ public final Completable onErrorComplete() {
     public final Completable onErrorComplete(final Func1<? super Throwable, Boolean> predicate) {
         requireNonNull(predicate);
         
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
-                unsafeSubscribe(new CompletableSubscriber() {
+            public void call(final rx.CompletableSubscriber s) {
+                unsafeSubscribe(new rx.CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
@@ -1716,11 +1832,11 @@ public void onSubscribe(Subscription d) {
      */
     public final Completable onErrorResumeNext(final Func1<? super Throwable, ? extends Completable> errorMapper) {
         requireNonNull(errorMapper);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
+            public void call(final rx.CompletableSubscriber s) {
                 final SerialSubscription sd = new SerialSubscription();
-                unsafeSubscribe(new CompletableSubscriber() {
+                unsafeSubscribe(new rx.CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
@@ -1746,7 +1862,7 @@ public void onError(Throwable e) {
                             return;
                         }
                         
-                        c.unsafeSubscribe(new CompletableSubscriber() {
+                        c.unsafeSubscribe(new rx.CompletableSubscriber() {
 
                             @Override
                             public void onCompleted() {
@@ -1883,7 +1999,7 @@ public final <T> Observable<T> startWith(Observable<T> other) {
      */
     public final Subscription subscribe() {
         final MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
-        unsafeSubscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new rx.CompletableSubscriber() {
             @Override
             public void onCompleted() {
                 mad.unsubscribe();
@@ -1916,7 +2032,7 @@ public final Subscription subscribe(final Action0 onComplete) {
         requireNonNull(onComplete);
         
         final MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
-        unsafeSubscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new rx.CompletableSubscriber() {
             boolean done;
             @Override
             public void onCompleted() {
@@ -1962,7 +2078,7 @@ public final Subscription subscribe(final Action0 onComplete, final Action1<? su
         requireNonNull(onError);
         
         final MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
-        unsafeSubscribe(new CompletableSubscriber() {
+        unsafeSubscribe(new rx.CompletableSubscriber() {
             boolean done;
             @Override
             public void onCompleted() {
@@ -2015,15 +2131,23 @@ private static void deliverUncaughtException(Throwable e) {
         thread.getUncaughtExceptionHandler().uncaughtException(thread, e);
     }
 
+    /**
+     * @deprecated Use {@link #unsafeSubscribe(rx.CompletableSubscriber)}.
+     */
+    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
+    public final void unsafeSubscribe(CompletableSubscriber s) {
+        unsafeSubscribe(fromOldSubscriber(s));
+    }
+
     /**
      * Subscribes the given CompletableSubscriber to this Completable instance.
      * @param s the CompletableSubscriber, not null
      * @throws NullPointerException if s is null
      */
-    public final void unsafeSubscribe(CompletableSubscriber s) {
+    public final void unsafeSubscribe(rx.CompletableSubscriber s) {
         requireNonNull(s);
         try {
-            CompletableOnSubscribe onSubscribeDecorated = RxJavaHooks.onCompletableStart(this, this.onSubscribe);
+            OnSubscribe onSubscribeDecorated = RxJavaHooks.onCompletableStart(this, this.onSubscribe);
             
             onSubscribeDecorated.call(s);
         } catch (NullPointerException ex) { // NOPMD 
@@ -2042,7 +2166,7 @@ public final void unsafeSubscribe(CompletableSubscriber s) {
      * @param s the CompletableSubscriber, not null
      * @throws NullPointerException if s is null
      */
-    public final void subscribe(CompletableSubscriber s) {
+    public final void subscribe(rx.CompletableSubscriber s) {
         if (!(s instanceof SafeCompletableSubscriber)) {
             s = new SafeCompletableSubscriber(s);
         }
@@ -2073,7 +2197,7 @@ private final <T> void unsafeSubscribe(final Subscriber<T> s, boolean callOnStar
             if (callOnStart) {
                 s.onStart();
             }
-            unsafeSubscribe(new CompletableSubscriber() {
+            unsafeSubscribe(new rx.CompletableSubscriber() {
                 @Override
                 public void onCompleted() {
                     s.onCompleted();
@@ -2126,9 +2250,9 @@ public final <T> void subscribe(Subscriber<T> s) {
     public final Completable subscribeOn(final Scheduler scheduler) {
         requireNonNull(scheduler);
         
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
+            public void call(final rx.CompletableSubscriber s) {
                 // FIXME cancellation of this schedule
                 
                 final Scheduler.Worker w = scheduler.createWorker();
@@ -2240,7 +2364,7 @@ public final <R> R to(Func1<? super Completable, R> converter) {
      * @return the new Observable created
      */
     public final <T> Observable<T> toObservable() {
-        return Observable.create(new OnSubscribe<T>() {
+        return Observable.create(new Observable.OnSubscribe<T>() {
             @Override
             public void call(Subscriber<? super T> s) {
                 unsafeSubscribe(s);
@@ -2261,7 +2385,7 @@ public final <T> Single<T> toSingle(final Func0<? extends T> completionValueFunc
         return Single.create(new rx.Single.OnSubscribe<T>() {
             @Override
             public void call(final SingleSubscriber<? super T> s) {
-                unsafeSubscribe(new CompletableSubscriber() {
+                unsafeSubscribe(new rx.CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
@@ -2323,10 +2447,10 @@ public T call() {
      */
     public final Completable unsubscribeOn(final Scheduler scheduler) {
         requireNonNull(scheduler);
-        return create(new CompletableOnSubscribe() {
+        return create(new OnSubscribe() {
             @Override
-            public void call(final CompletableSubscriber s) {
-                unsafeSubscribe(new CompletableSubscriber() {
+            public void call(final rx.CompletableSubscriber s) {
+                unsafeSubscribe(new rx.CompletableSubscriber() {
 
                     @Override
                     public void onCompleted() {
diff --git a/src/main/java/rx/CompletableSubscriber.java b/src/main/java/rx/CompletableSubscriber.java
new file mode 100644
index 0000000000..2aef783769
--- /dev/null
+++ b/src/main/java/rx/CompletableSubscriber.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx;
+
+import rx.annotations.Experimental;
+
+/**
+ * Represents the subscription API callbacks when subscribing to a Completable instance.
+ */
+@Experimental
+public interface CompletableSubscriber {
+    /**
+     * Called once the deferred computation completes normally.
+     */
+    void onCompleted();
+
+    /**
+     * Called once if the deferred computation 'throws' an exception.
+     * @param e the exception, not null.
+     */
+    void onError(Throwable e);
+
+    /**
+     * Called once by the Completable to set a Subscription on this instance which
+     * then can be used to cancel the subscription at any time.
+     * @param d the Subscription instance to call dispose on for cancellation, not null
+     */
+    void onSubscribe(Subscription d);
+}
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index bec23882ba..05d1b00f96 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -2021,7 +2021,7 @@ public void onCompleted() {
                     }
                 };
 
-                final Completable.CompletableSubscriber so = new Completable.CompletableSubscriber() {
+                final CompletableSubscriber so = new CompletableSubscriber() {
                     @Override
                     public void onCompleted() {
                         onError(new CancellationException("Stream was canceled before emitting a terminal event."));
diff --git a/src/main/java/rx/internal/operators/CompletableFlatMapSingleToCompletable.java b/src/main/java/rx/internal/operators/CompletableFlatMapSingleToCompletable.java
index f5d0a44123..a6289d4355 100644
--- a/src/main/java/rx/internal/operators/CompletableFlatMapSingleToCompletable.java
+++ b/src/main/java/rx/internal/operators/CompletableFlatMapSingleToCompletable.java
@@ -17,15 +17,15 @@
 package rx.internal.operators;
 
 import rx.Completable;
-import rx.Completable.CompletableOnSubscribe;
-import rx.Completable.CompletableSubscriber;
+import rx.Completable.OnSubscribe;
+import rx.CompletableSubscriber;
 import rx.Single;
 import rx.SingleSubscriber;
 import rx.Subscription;
 import rx.exceptions.Exceptions;
 import rx.functions.Func1;
 
-public final class CompletableFlatMapSingleToCompletable<T> implements CompletableOnSubscribe {
+public final class CompletableFlatMapSingleToCompletable<T> implements OnSubscribe {
 
     final Single<T> source;
 
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
index 96cccc23f7..ecf658b94a 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
@@ -19,13 +19,13 @@
 import java.util.concurrent.atomic.*;
 
 import rx.*;
-import rx.Completable.*;
+import rx.Completable.OnSubscribe;
 import rx.exceptions.MissingBackpressureException;
 import rx.internal.util.unsafe.SpscArrayQueue;
 import rx.plugins.RxJavaHooks;
 import rx.subscriptions.SerialSubscription;
 
-public final class CompletableOnSubscribeConcat implements CompletableOnSubscribe {
+public final class CompletableOnSubscribeConcat implements OnSubscribe {
     final Observable<Completable> sources;
     final int prefetch;
     
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
index 0b132acd43..00b033e442 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
@@ -19,10 +19,10 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.*;
-import rx.Completable.*;
+import rx.Completable.OnSubscribe;
 import rx.subscriptions.SerialSubscription;
 
-public final class CompletableOnSubscribeConcatArray implements CompletableOnSubscribe {
+public final class CompletableOnSubscribeConcatArray implements OnSubscribe {
     final Completable[] sources;
     
     public CompletableOnSubscribeConcatArray(Completable[] sources) {
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
index 0ce11fde78..feaa0a984e 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
@@ -20,10 +20,10 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.*;
-import rx.Completable.*;
+import rx.Completable.OnSubscribe;
 import rx.subscriptions.*;
 
-public final class CompletableOnSubscribeConcatIterable implements CompletableOnSubscribe {
+public final class CompletableOnSubscribeConcatIterable implements OnSubscribe {
     final Iterable<? extends Completable> sources;
     
     public CompletableOnSubscribeConcatIterable(Iterable<? extends Completable> sources) {
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
index 48dce53c9c..0eecf3fa32 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
@@ -21,13 +21,13 @@
 import java.util.concurrent.atomic.*;
 
 import rx.*;
-import rx.Completable.*;
+import rx.Completable.OnSubscribe;
 import rx.Observable;
 import rx.exceptions.CompositeException;
 import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
-public final class CompletableOnSubscribeMerge implements CompletableOnSubscribe {
+public final class CompletableOnSubscribeMerge implements OnSubscribe {
     final Observable<Completable> source;
     final int maxConcurrency;
     final boolean delayErrors;
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
index d80f50abf6..7af6636d28 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
@@ -19,11 +19,11 @@
 import java.util.concurrent.atomic.*;
 
 import rx.*;
-import rx.Completable.*;
+import rx.Completable.OnSubscribe;
 import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
-public final class CompletableOnSubscribeMergeArray implements CompletableOnSubscribe {
+public final class CompletableOnSubscribeMergeArray implements OnSubscribe {
     final Completable[] sources;
     
     public CompletableOnSubscribeMergeArray(Completable[] sources) {
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java
index d98a6a039e..d8dfac8f2f 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java
@@ -21,10 +21,10 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.*;
-import rx.Completable.*;
+import rx.Completable.OnSubscribe;
 import rx.subscriptions.CompositeSubscription;
 
-public final class CompletableOnSubscribeMergeDelayErrorArray implements CompletableOnSubscribe {
+public final class CompletableOnSubscribeMergeDelayErrorArray implements OnSubscribe {
     final Completable[] sources;
     
     public CompletableOnSubscribeMergeDelayErrorArray(Completable[] sources) {
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
index 55583c85ad..6678439526 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
@@ -20,11 +20,11 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.*;
-import rx.Completable.*;
+import rx.Completable.OnSubscribe;
 import rx.internal.util.unsafe.MpscLinkedQueue;
 import rx.subscriptions.CompositeSubscription;
 
-public final class CompletableOnSubscribeMergeDelayErrorIterable implements CompletableOnSubscribe {
+public final class CompletableOnSubscribeMergeDelayErrorIterable implements OnSubscribe {
     final Iterable<? extends Completable> sources;
     
     public CompletableOnSubscribeMergeDelayErrorIterable(Iterable<? extends Completable> sources) {
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
index 9d09393bbe..459996d0c4 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
@@ -20,11 +20,11 @@
 import java.util.concurrent.atomic.*;
 
 import rx.*;
-import rx.Completable.*;
+import rx.Completable.OnSubscribe;
 import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
-public final class CompletableOnSubscribeMergeIterable implements CompletableOnSubscribe {
+public final class CompletableOnSubscribeMergeIterable implements OnSubscribe {
     final Iterable<? extends Completable> sources;
     
     public CompletableOnSubscribeMergeIterable(Iterable<? extends Completable> sources) {
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
index 672cfad61b..e88d6ae427 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
@@ -20,12 +20,12 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.*;
-import rx.Completable.*;
+import rx.Completable.OnSubscribe;
 import rx.functions.Action0;
 import rx.plugins.RxJavaHooks;
 import rx.subscriptions.CompositeSubscription;
 
-public final class CompletableOnSubscribeTimeout implements CompletableOnSubscribe {
+public final class CompletableOnSubscribeTimeout implements OnSubscribe {
     
     final Completable source;
     final long timeout;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
index c8d7eaf52f..c562013d88 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
@@ -16,7 +16,7 @@
 package rx.internal.operators;
 
 import rx.*;
-import rx.Completable.CompletableSubscriber;
+import rx.CompletableSubscriber;
 import rx.exceptions.AssemblyStackTraceException;
 
 /**
@@ -26,9 +26,9 @@
  *
  * @param <T> the value type
  */
-public final class OnSubscribeOnAssemblyCompletable<T> implements Completable.CompletableOnSubscribe {
+public final class OnSubscribeOnAssemblyCompletable<T> implements Completable.OnSubscribe {
 
-    final Completable.CompletableOnSubscribe source;
+    final Completable.OnSubscribe source;
     
     final String stacktrace;
 
@@ -38,13 +38,13 @@ public final class OnSubscribeOnAssemblyCompletable<T> implements Completable.Co
      */
     public static volatile boolean fullStackTrace;
     
-    public OnSubscribeOnAssemblyCompletable(Completable.CompletableOnSubscribe source) {
+    public OnSubscribeOnAssemblyCompletable(Completable.OnSubscribe source) {
         this.source = source;
         this.stacktrace = OnSubscribeOnAssembly.createStacktrace();
     }
     
     @Override
-    public void call(Completable.CompletableSubscriber t) {
+    public void call(CompletableSubscriber t) {
         source.call(new OnAssemblyCompletableSubscriber(t, stacktrace));
     }
     
diff --git a/src/main/java/rx/internal/schedulers/SchedulerWhen.java b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
index b1312a458b..16a5f3dcda 100644
--- a/src/main/java/rx/internal/schedulers/SchedulerWhen.java
+++ b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
@@ -20,9 +20,8 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Completable;
-import rx.Completable.CompletableOnSubscribe;
-import rx.Completable.CompletableSubscriber;
-import rx.Scheduler.Worker;
+import rx.Completable.OnSubscribe;
+import rx.CompletableSubscriber;
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
@@ -143,7 +142,7 @@ public Worker createWorker() {
 		Observable<Completable> actions = actionSubject.map(new Func1<ScheduledAction, Completable>() {
 			@Override
 			public Completable call(final ScheduledAction action) {
-				return Completable.create(new CompletableOnSubscribe() {
+				return Completable.create(new OnSubscribe() {
 					@Override
 					public void call(CompletableSubscriber actionCompletable) {
 						actionCompletable.onSubscribe(action);
diff --git a/src/main/java/rx/observers/AsyncCompletableSubscriber.java b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
index 488fc27f26..3b9547b301 100644
--- a/src/main/java/rx/observers/AsyncCompletableSubscriber.java
+++ b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
@@ -17,7 +17,7 @@
 
 import java.util.concurrent.atomic.AtomicReference;
 
-import rx.Completable.CompletableSubscriber;
+import rx.CompletableSubscriber;
 import rx.Subscription;
 import rx.annotations.Experimental;
 import rx.plugins.RxJavaHooks;
diff --git a/src/main/java/rx/observers/SafeCompletableSubscriber.java b/src/main/java/rx/observers/SafeCompletableSubscriber.java
index 80f9abac2d..cac72dd2b5 100644
--- a/src/main/java/rx/observers/SafeCompletableSubscriber.java
+++ b/src/main/java/rx/observers/SafeCompletableSubscriber.java
@@ -15,7 +15,7 @@
  */
 package rx.observers;
 
-import rx.Completable.CompletableSubscriber;
+import rx.CompletableSubscriber;
 import rx.Subscription;
 import rx.annotations.Experimental;
 import rx.exceptions.*;
diff --git a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
index 7faf996724..b4596655cf 100644
--- a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
@@ -40,18 +40,18 @@
 @Experimental
 public abstract class RxJavaCompletableExecutionHook { // NOPMD 
     /**
-     * Invoked during the construction by {@link Completable#create(Completable.CompletableOnSubscribe)}
+     * Invoked during the construction by {@link Completable#create(Completable.OnSubscribe)}
      * <p>
      * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
      * logging, metrics and other such things and pass through the function.
      *
      * @param f
-     *            original {@link rx.Completable.CompletableOnSubscribe}<{@code T}> to be executed
-     * @return {@link rx.Completable.CompletableOnSubscribe} function that can be modified, decorated, replaced or just
+     *            original {@link Completable.OnSubscribe}<{@code T}> to be executed
+     * @return {@link Completable.OnSubscribe} function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
     @Deprecated
-    public Completable.CompletableOnSubscribe onCreate(Completable.CompletableOnSubscribe f) {
+    public Completable.OnSubscribe onCreate(Completable.OnSubscribe f) {
         return f;
     }
 
@@ -63,12 +63,12 @@ public Completable.CompletableOnSubscribe onCreate(Completable.CompletableOnSubs
      *
      * @param completableInstance the target completable instance
      * @param onSubscribe
-     *            original {@link rx.Completable.CompletableOnSubscribe}<{@code T}> to be executed
-     * @return {@link rx.Completable.CompletableOnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
+     *            original {@link Completable.OnSubscribe}<{@code T}> to be executed
+     * @return {@link Completable.OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
     @Deprecated
-    public Completable.CompletableOnSubscribe onSubscribeStart(Completable completableInstance, final Completable.CompletableOnSubscribe onSubscribe) {
+    public Completable.OnSubscribe onSubscribeStart(Completable completableInstance, final Completable.OnSubscribe onSubscribe) {
         // pass through by default
         return onSubscribe;
     }
@@ -93,16 +93,16 @@ public Throwable onSubscribeError(Throwable e) {
      * Invoked just as the operator functions is called to bind two operations together into a new
      * {@link Completable} and the return value is used as the lifted function
      * <p>
-     * This can be used to decorate or replace the {@link rx.Completable.CompletableOperator} instance or just perform extra
+     * This can be used to decorate or replace the {@link Completable.Operator} instance or just perform extra
      * logging, metrics and other such things and pass through the onSubscribe.
      *
      * @param lift
-     *            original {@link rx.Completable.CompletableOperator}{@code <R, T>}
-     * @return {@link rx.Completable.CompletableOperator}{@code <R, T>} function that can be modified, decorated, replaced or just
+     *            original {@link Completable.Operator}{@code <R, T>}
+     * @return {@link Completable.Operator}{@code <R, T>} function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
     @Deprecated
-    public Completable.CompletableOperator onLift(final Completable.CompletableOperator lift) {
+    public Completable.Operator onLift(final Completable.Operator lift) {
         return lift;
     }
 }
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index f528f66f76..d438987400 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -19,8 +19,6 @@
 import java.util.concurrent.ScheduledExecutorService;
 
 import rx.*;
-import rx.Completable.*;
-import rx.Observable.*;
 import rx.annotations.Experimental;
 import rx.functions.*;
 import rx.internal.operators.*;
@@ -47,7 +45,7 @@ public final class RxJavaHooks {
     @SuppressWarnings("rawtypes")
     static volatile Func1<Single.OnSubscribe, Single.OnSubscribe> onSingleCreate;
 
-    static volatile Func1<Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> onCompletableCreate;
+    static volatile Func1<Completable.OnSubscribe, Completable.OnSubscribe> onCompletableCreate;
 
     @SuppressWarnings("rawtypes")
     static volatile Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> onObservableStart;
@@ -55,7 +53,7 @@ public final class RxJavaHooks {
     @SuppressWarnings("rawtypes")
     static volatile Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> onSingleStart;
 
-    static volatile Func2<Completable, Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> onCompletableStart;
+    static volatile Func2<Completable, Completable.OnSubscribe, Completable.OnSubscribe> onCompletableStart;
 
     static volatile Func1<Scheduler, Scheduler> onComputationScheduler;
 
@@ -78,12 +76,12 @@ public final class RxJavaHooks {
     static volatile Func1<Throwable, Throwable> onCompletableSubscribeError;
 
     @SuppressWarnings("rawtypes")
-    static volatile Func1<Operator, Operator> onObservableLift;
+    static volatile Func1<Observable.Operator, Observable.Operator> onObservableLift;
 
     @SuppressWarnings("rawtypes")
-    static volatile Func1<Operator, Operator> onSingleLift;
+    static volatile Func1<Observable.Operator, Observable.Operator> onSingleLift;
 
-    static volatile Func1<CompletableOperator, CompletableOperator> onCompletableLift;
+    static volatile Func1<Completable.Operator, Completable.Operator> onCompletableLift;
 
     /** Initialize with the default delegation to the original RxJavaPlugins. */
     static {
@@ -108,9 +106,9 @@ public void call(Throwable e) {
             }
         };
         
-        onObservableStart = new Func2<Observable, OnSubscribe, OnSubscribe>() {
+        onObservableStart = new Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe>() {
             @Override
-            public OnSubscribe call(Observable t1, OnSubscribe t2) {
+            public Observable.OnSubscribe call(Observable t1, Observable.OnSubscribe t2) {
                 return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeStart(t1, t2);
             }
         };
@@ -136,9 +134,9 @@ public Subscription call(Subscription f) {
             }
         };
         
-        onCompletableStart = new Func2<Completable, Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe>() {
+        onCompletableStart = new Func2<Completable, Completable.OnSubscribe, Completable.OnSubscribe>() {
             @Override
-            public Completable.CompletableOnSubscribe call(Completable t1, Completable.CompletableOnSubscribe t2) {
+            public Completable.OnSubscribe call(Completable t1, Completable.OnSubscribe t2) {
                 return RxJavaPlugins.getInstance().getCompletableExecutionHook().onSubscribeStart(t1, t2);
             }
         };
@@ -157,9 +155,9 @@ public Throwable call(Throwable t) {
             }
         };
         
-        onObservableLift = new Func1<Operator, Operator>() {
+        onObservableLift = new Func1<Observable.Operator, Observable.Operator>() {
             @Override
-            public Operator call(Operator t) {
+            public Observable.Operator call(Observable.Operator t) {
                 return RxJavaPlugins.getInstance().getObservableExecutionHook().onLift(t);
             }
         };
@@ -171,9 +169,9 @@ public Throwable call(Throwable t) {
             }
         };
         
-        onSingleLift = new Func1<Operator, Operator>() {
+        onSingleLift = new Func1<Observable.Operator, Observable.Operator>() {
             @Override
-            public Operator call(Operator t) {
+            public Observable.Operator call(Observable.Operator t) {
                 return RxJavaPlugins.getInstance().getSingleExecutionHook().onLift(t);
             }
         };
@@ -185,9 +183,9 @@ public Throwable call(Throwable t) {
             }
         };
         
-        onCompletableLift = new Func1<CompletableOperator, CompletableOperator>() {
+        onCompletableLift = new Func1<Completable.Operator, Completable.Operator>() {
             @Override
-            public CompletableOperator call(CompletableOperator t) {
+            public Completable.Operator call(Completable.Operator t) {
                 return RxJavaPlugins.getInstance().getCompletableExecutionHook().onLift(t);
             }
         };
@@ -197,9 +195,9 @@ public CompletableOperator call(CompletableOperator t) {
     
     @SuppressWarnings({ "rawtypes", "unchecked", "deprecation" })
     static void initCreate() {
-        onObservableCreate = new Func1<OnSubscribe, OnSubscribe>() {
+        onObservableCreate = new Func1<Observable.OnSubscribe, Observable.OnSubscribe>() {
             @Override
-            public OnSubscribe call(OnSubscribe f) {
+            public Observable.OnSubscribe call(Observable.OnSubscribe f) {
                 return RxJavaPlugins.getInstance().getObservableExecutionHook().onCreate(f);
             }
         };
@@ -211,9 +209,9 @@ public rx.Single.OnSubscribe call(rx.Single.OnSubscribe f) {
             }
         };
 
-        onCompletableCreate = new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
+        onCompletableCreate = new Func1<Completable.OnSubscribe, Completable.OnSubscribe>() {
             @Override
-            public CompletableOnSubscribe call(CompletableOnSubscribe f) {
+            public Completable.OnSubscribe call(Completable.OnSubscribe f) {
                 return RxJavaPlugins.getInstance().getCompletableExecutionHook().onCreate(f);
             }
         };
@@ -327,7 +325,7 @@ static void signalUncaught(Throwable ex) {
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
     public static <T> Observable.OnSubscribe<T> onCreate(Observable.OnSubscribe<T> onSubscribe) {
-        Func1<OnSubscribe, OnSubscribe> f = onObservableCreate;
+        Func1<Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableCreate;
         if (f != null) {
             return f.call(onSubscribe);
         }
@@ -354,8 +352,8 @@ public static <T> Single.OnSubscribe<T> onCreate(Single.OnSubscribe<T> onSubscri
      * @param onSubscribe the original OnSubscribe logic
      * @return the original or replacement OnSubscribe instance
      */
-    public static Completable.CompletableOnSubscribe onCreate(Completable.CompletableOnSubscribe onSubscribe) {
-        Func1<Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> f = onCompletableCreate;
+    public static Completable.OnSubscribe onCreate(Completable.OnSubscribe onSubscribe) {
+        Func1<Completable.OnSubscribe, Completable.OnSubscribe> f = onCompletableCreate;
         if (f != null) {
             return f.call(onSubscribe);
         }
@@ -423,8 +421,8 @@ public static Action0 onScheduledAction(Action0 action) {
      * @return the original or alternative action that will be subscribed to
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
-    public static <T> OnSubscribe<T> onObservableStart(Observable<T> instance, OnSubscribe<T> onSubscribe) {
-        Func2<Observable, OnSubscribe, OnSubscribe> f = onObservableStart;
+    public static <T> Observable.OnSubscribe onObservableStart(Observable<T> instance, Observable.OnSubscribe onSubscribe) {
+        Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableStart;
         if (f != null) {
             return f.call(instance, onSubscribe);
         }
@@ -465,8 +463,8 @@ public static Throwable onObservableError(Throwable error) {
      * @return the original or alternative operator that will be subscribed to
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
-    public static <T, R> Operator<R, T> onObservableLift(Operator<R, T> operator) {
-        Func1<Operator, Operator> f = onObservableLift;
+    public static <T, R> Observable.Operator<R, T> onObservableLift(Observable.Operator<R, T> operator) {
+        Func1<Observable.Operator, Observable.Operator> f = onObservableLift;
         if (f != null) {
             return f.call(operator);
         }
@@ -481,7 +479,7 @@ public static <T, R> Operator<R, T> onObservableLift(Operator<R, T> operator) {
      * @return the original or alternative action that will be subscribed to
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
-    public static <T> Observable.OnSubscribe<T> onSingleStart(Single<T> instance, Observable.OnSubscribe<T> onSubscribe) {
+    public static <T> Observable.OnSubscribe onSingleStart(Single<T> instance, Observable.OnSubscribe onSubscribe) {
         Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> f = onSingleStart;
         if (f != null) {
             return f.call(instance, onSubscribe);
@@ -523,8 +521,8 @@ public static Throwable onSingleError(Throwable error) {
      * @return the original or alternative operator that will be subscribed to
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
-    public static <T, R> Operator<R, T> onSingleLift(Operator<R, T> operator) {
-        Func1<Operator, Operator> f = onSingleLift;
+    public static <T, R> Observable.Operator<R, T> onSingleLift(Observable.Operator<R, T> operator) {
+        Func1<Observable.Operator, Observable.Operator> f = onSingleLift;
         if (f != null) {
             return f.call(operator);
         }
@@ -538,8 +536,8 @@ public static <T, R> Operator<R, T> onSingleLift(Operator<R, T> operator) {
      * @param onSubscribe the original OnSubscribe action
      * @return the original or alternative action that will be subscribed to
      */
-    public static <T> Completable.CompletableOnSubscribe onCompletableStart(Completable instance, Completable.CompletableOnSubscribe onSubscribe) {
-        Func2<Completable, CompletableOnSubscribe, CompletableOnSubscribe> f = onCompletableStart;
+    public static <T> Completable.OnSubscribe onCompletableStart(Completable instance, Completable.OnSubscribe onSubscribe) {
+        Func2<Completable, Completable.OnSubscribe, Completable.OnSubscribe> f = onCompletableStart;
         if (f != null) {
             return f.call(instance, onSubscribe);
         }
@@ -566,8 +564,8 @@ public static Throwable onCompletableError(Throwable error) {
      * @param operator the original operator
      * @return the original or alternative operator that will be subscribed to
      */
-    public static <T, R> Completable.CompletableOperator onCompletableLift(Completable.CompletableOperator operator) {
-        Func1<CompletableOperator, CompletableOperator> f = onCompletableLift;
+    public static <T, R> Completable.Operator onCompletableLift(Completable.Operator operator) {
+        Func1<Completable.Operator, Completable.Operator> f = onCompletableLift;
         if (f != null) {
             return f.call(operator);
         }
@@ -602,7 +600,7 @@ public static void setOnError(Action1<Throwable> onError) {
      * and should return a CompletableOnSubscribe.
      */
     public static void setOnCompletableCreate(
-            Func1<Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> onCompletableCreate) {
+            Func1<Completable.OnSubscribe, Completable.OnSubscribe> onCompletableCreate) {
         if (lockdown) {
             return;
         }
@@ -731,7 +729,7 @@ public static void setOnScheduleAction(Func1<Action0, Action0> onScheduleAction)
      * that gets actually subscribed to.
      */
     public static void setOnCompletableStart(
-            Func2<Completable, Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> onCompletableStart) {
+            Func2<Completable, Completable.OnSubscribe, Completable.OnSubscribe> onCompletableStart) {
         if (lockdown) {
             return;
         }
@@ -916,7 +914,7 @@ public static Func1<Throwable, Throwable> getOnObservableSubscribeError() {
      * return an Operator instance.
      */
     @SuppressWarnings("rawtypes")
-    public static void setOnObservableLift(Func1<Operator, Operator> onObservableLift) {
+    public static void setOnObservableLift(Func1<Observable.Operator, Observable.Operator> onObservableLift) {
         if (lockdown) {
             return;
         }
@@ -931,7 +929,7 @@ public static void setOnObservableLift(Func1<Operator, Operator> onObservableLif
      * @return the current hook function
      */
     @SuppressWarnings("rawtypes")
-    public static Func1<Operator, Operator> getOnObservableLift() {
+    public static Func1<Observable.Operator, Observable.Operator> getOnObservableLift() {
         return onObservableLift;
     }
 
@@ -947,7 +945,7 @@ public static Func1<Operator, Operator> getOnObservableLift() {
      * return an Operator instance.
      */
     @SuppressWarnings("rawtypes")
-    public static void setOnSingleLift(Func1<Operator, Operator> onSingleLift) {
+    public static void setOnSingleLift(Func1<Observable.Operator, Observable.Operator> onSingleLift) {
         if (lockdown) {
             return;
         }
@@ -962,7 +960,7 @@ public static void setOnSingleLift(Func1<Operator, Operator> onSingleLift) {
      * @return the current hook function
      */
     @SuppressWarnings("rawtypes")
-    public static Func1<Operator, Operator> getOnSingleLift() {
+    public static Func1<Observable.Operator, Observable.Operator> getOnSingleLift() {
         return onSingleLift;
     }
 
@@ -977,7 +975,7 @@ public static Func1<Operator, Operator> getOnSingleLift() {
      * @param onCompletableLift the function that is called with original Operator and should
      * return an Operator instance.
      */
-    public static void setOnCompletableLift(Func1<CompletableOperator, CompletableOperator> onCompletableLift) {
+    public static void setOnCompletableLift(Func1<Completable.Operator, Completable.Operator> onCompletableLift) {
         if (lockdown) {
             return;
         }
@@ -991,7 +989,7 @@ public static void setOnCompletableLift(Func1<CompletableOperator, CompletableOp
      * This operation is threadsafe.
      * @return the current hook function
      */
-    public static Func1<CompletableOperator, CompletableOperator> getOnCompletableLift() {
+    public static Func1<Completable.Operator, Completable.Operator> getOnCompletableLift() {
         return onCompletableLift;
     }
 
@@ -1082,7 +1080,7 @@ public static Func1<Single.OnSubscribe, Single.OnSubscribe> getOnSingleCreate()
      * This operation is threadsafe.
      * @return the current hook function
      */
-    public static Func1<Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> getOnCompletableCreate() {
+    public static Func1<Completable.OnSubscribe, Completable.OnSubscribe> getOnCompletableCreate() {
         return onCompletableCreate;
     }
     
@@ -1093,7 +1091,7 @@ public static Func1<Completable.CompletableOnSubscribe, Completable.CompletableO
      * This operation is threadsafe.
      * @return the current hook function
      */
-    public static Func2<Completable, Completable.CompletableOnSubscribe, Completable.CompletableOnSubscribe> getOnCompletableStart() {
+    public static Func2<Completable, Completable.OnSubscribe, Completable.OnSubscribe> getOnCompletableStart() {
         return onCompletableStart;
     }
     
@@ -1178,9 +1176,9 @@ public static void enableAssemblyTracking() {
             return;
         }
         
-        onObservableCreate = new Func1<OnSubscribe, OnSubscribe>() {
+        onObservableCreate = new Func1<Observable.OnSubscribe, Observable.OnSubscribe>() {
             @Override
-            public OnSubscribe call(OnSubscribe f) {
+            public Observable.OnSubscribe call(Observable.OnSubscribe f) {
                 return new OnSubscribeOnAssembly(f);
             }
         };
@@ -1192,9 +1190,9 @@ public rx.Single.OnSubscribe call(rx.Single.OnSubscribe f) {
             }
         };
 
-        onCompletableCreate = new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
+        onCompletableCreate = new Func1<Completable.OnSubscribe, Completable.OnSubscribe>() {
             @Override
-            public CompletableOnSubscribe call(CompletableOnSubscribe f) {
+            public Completable.OnSubscribe call(Completable.OnSubscribe f) {
                 return new OnSubscribeOnAssemblyCompletable(f);
             }
         };
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 6ae30f4293..2edb0a0d10 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -27,7 +27,6 @@
 import org.junit.*;
 
 import rx.Completable.*;
-import rx.Observable.OnSubscribe;
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.observers.TestSubscriber;
@@ -98,7 +97,7 @@ static final class NormalCompletable extends AtomicInteger {
         /** */
         private static final long serialVersionUID = 7192337844700923752L;
         
-        public final Completable completable = Completable.create(new CompletableOnSubscribe() {
+        public final Completable completable = Completable.create(new OnSubscribe() {
             @Override
             public void call(CompletableSubscriber s) {
                 getAndIncrement();
@@ -124,7 +123,7 @@ static final class ErrorCompletable extends AtomicInteger {
         /** */
         private static final long serialVersionUID = 7192337844700923752L;
         
-        public final Completable completable = Completable.create(new CompletableOnSubscribe() {
+        public final Completable completable = Completable.create(new OnSubscribe() {
             @Override
             public void call(CompletableSubscriber s) {
                 getAndIncrement();
@@ -386,13 +385,13 @@ public void andThenError() {
         TestSubscriber<String> ts = new TestSubscriber<String>(0);
         final AtomicBoolean hasRun = new AtomicBoolean(false);
         final Exception e = new Exception();
-        Completable.create(new CompletableOnSubscribe() {
+        Completable.create(new OnSubscribe() {
                 @Override
                 public void call(CompletableSubscriber cs) {
                     cs.onError(e);
                 }
             })
-            .andThen(Observable.<String>create(new OnSubscribe<String>() {
+            .andThen(Observable.<String>create(new Observable.OnSubscribe<String>() {
                 @Override
                 public void call(Subscriber<? super String> s) {
                     hasRun.set(true);
@@ -477,12 +476,12 @@ public void andThenSingleSubscribeOn() {
     
     @Test(expected = NullPointerException.class)
     public void createNull() {
-        Completable.create(null);
+        Completable.create((Completable.OnSubscribe)null);
     }
     
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void createOnSubscribeThrowsNPE() {
-        Completable c = Completable.create(new CompletableOnSubscribe() {
+        Completable c = Completable.create(new OnSubscribe() {
             @Override
             public void call(CompletableSubscriber s) { throw new NullPointerException(); }
         });
@@ -493,7 +492,7 @@ public void createOnSubscribeThrowsNPE() {
     @Test(timeout = 5000)
     public void createOnSubscribeThrowsRuntimeException() {
         try {
-            Completable c = Completable.create(new CompletableOnSubscribe() {
+            Completable c = Completable.create(new OnSubscribe() {
                 @Override
                 public void call(CompletableSubscriber s) {
                     throw new TestException();
@@ -1578,7 +1577,7 @@ public Completable call(Object v) {
     
     @Test(timeout = 5000)
     public void composeNormal() {
-        Completable c = error.completable.compose(new CompletableTransformer() {
+        Completable c = error.completable.compose(new Transformer() {
             @Override
             public Completable call(Completable n) {
                 return n.onErrorComplete();
@@ -2095,12 +2094,12 @@ public void getNullUnit() {
     
     @Test(expected = NullPointerException.class)
     public void liftNull() {
-        normal.completable.lift(null);
+        normal.completable.lift((Completable.Operator)null);
     }
     
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void liftReturnsNull() {
-        Completable c = normal.completable.lift(new CompletableOperator() {
+        Completable c = normal.completable.lift(new Operator() {
             @Override
             public CompletableSubscriber call(CompletableSubscriber v) {
                 return null;
@@ -2110,7 +2109,7 @@ public CompletableSubscriber call(CompletableSubscriber v) {
         c.await();
     }
 
-    final static class CompletableOperatorSwap implements CompletableOperator {
+    final static class CompletableOperatorSwap implements Operator {
         @Override
         public CompletableSubscriber call(final CompletableSubscriber v) {
             return new CompletableSubscriber() {
@@ -2720,7 +2719,7 @@ public void subscribeOnNull() {
     public void subscribeOnNormal() {
         final AtomicReference<String> name = new  AtomicReference<String>();
         
-        Completable c = Completable.create(new CompletableOnSubscribe() {
+        Completable c = Completable.create(new OnSubscribe() {
             @Override
             public void call(CompletableSubscriber s) { 
                 name.set(Thread.currentThread().getName());
@@ -2738,7 +2737,7 @@ public void call(CompletableSubscriber s) {
     public void subscribeOnError() {
         final AtomicReference<String> name = new  AtomicReference<String>();
         
-        Completable c = Completable.create(new CompletableOnSubscribe() {
+        Completable c = Completable.create(new OnSubscribe() {
             @Override
             public void call(CompletableSubscriber s) { 
                 name.set(Thread.currentThread().getName());
@@ -4036,24 +4035,24 @@ public void onNext(Object t) {
         }
     }
 
-    private Func1<CompletableOnSubscribe, CompletableOnSubscribe> onCreate;
+    private Func1<OnSubscribe, OnSubscribe> onCreate;
     
-    private Func2<Completable, CompletableOnSubscribe, CompletableOnSubscribe> onStart;
+    private Func2<Completable, OnSubscribe, OnSubscribe> onStart;
 
     @Before
     public void setUp() throws Exception {
-        onCreate = spy(new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
+        onCreate = spy(new Func1<OnSubscribe, OnSubscribe>() {
             @Override
-            public CompletableOnSubscribe call(CompletableOnSubscribe t) {
+            public OnSubscribe call(OnSubscribe t) {
                 return t;
             }
         });
         
         RxJavaHooks.setOnCompletableCreate(onCreate);
         
-        onStart = spy(new Func2<Completable, CompletableOnSubscribe, CompletableOnSubscribe>() {
+        onStart = spy(new Func2<Completable, OnSubscribe, OnSubscribe>() {
             @Override
-            public CompletableOnSubscribe call(Completable t1, CompletableOnSubscribe t2) {
+            public OnSubscribe call(Completable t1, OnSubscribe t2) {
                 return t2;
             }
         });
@@ -4068,7 +4067,7 @@ public void after() {
 
     @Test
     public void testHookCreate() {
-        CompletableOnSubscribe subscriber = mock(CompletableOnSubscribe.class);
+        OnSubscribe subscriber = mock(OnSubscribe.class);
         Completable.create(subscriber);
 
         verify(onCreate, times(1)).call(subscriber);
@@ -4078,27 +4077,27 @@ public void testHookCreate() {
     public void testHookSubscribeStart() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
 
-        Completable completable = Completable.create(new CompletableOnSubscribe() {
+        Completable completable = Completable.create(new OnSubscribe() {
             @Override public void call(CompletableSubscriber s) {
                 s.onCompleted();
             }
         });
         completable.subscribe(ts);
 
-        verify(onStart, times(1)).call(eq(completable), any(Completable.CompletableOnSubscribe.class));
+        verify(onStart, times(1)).call(eq(completable), any(OnSubscribe.class));
     }
 
     @Test
     public void testHookUnsafeSubscribeStart() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
-        Completable completable = Completable.create(new CompletableOnSubscribe() {
+        Completable completable = Completable.create(new OnSubscribe() {
             @Override public void call(CompletableSubscriber s) {
                 s.onCompleted();
             }
         });
         completable.unsafeSubscribe(ts);
 
-        verify(onStart, times(1)).call(eq(completable), any(Completable.CompletableOnSubscribe.class));
+        verify(onStart, times(1)).call(eq(completable), any(OnSubscribe.class));
     }
 
     @Test
diff --git a/src/test/java/rx/observers/CompletableSubscriberTest.java b/src/test/java/rx/observers/CompletableSubscriberTest.java
index be598dc04c..e7281c0796 100644
--- a/src/test/java/rx/observers/CompletableSubscriberTest.java
+++ b/src/test/java/rx/observers/CompletableSubscriberTest.java
@@ -21,7 +21,7 @@
 
 import org.junit.*;
 
-import rx.Completable.CompletableSubscriber;
+import rx.CompletableSubscriber;
 import rx.exceptions.*;
 import rx.Subscription;
 import rx.subscriptions.Subscriptions;
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index a1df503815..ff21d14bc6 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -26,9 +26,7 @@
 import org.junit.Test;
 
 import rx.*;
-import rx.Completable.*;
 import rx.Observable;
-import rx.Observable.*;
 import rx.Scheduler.Worker;
 import rx.exceptions.*;
 import rx.functions.*;
@@ -307,9 +305,9 @@ public void overrideNewThreadScheduler() {
     @Test
     public void observableCreate() {
         try {
-            RxJavaHooks.setOnObservableCreate(new Func1<OnSubscribe, OnSubscribe>() {
+            RxJavaHooks.setOnObservableCreate(new Func1<Observable.OnSubscribe, Observable.OnSubscribe>() {
                 @Override
-                public OnSubscribe call(OnSubscribe t) {
+                public Observable.OnSubscribe call(Observable.OnSubscribe t) {
                     return new OnSubscribeRange(1, 2);
                 }
             });
@@ -338,9 +336,9 @@ public OnSubscribe call(OnSubscribe t) {
     @Test
     public void observableStart() {
         try {
-            RxJavaHooks.setOnObservableStart(new Func2<Observable, OnSubscribe, OnSubscribe>() {
+            RxJavaHooks.setOnObservableStart(new Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe>() {
                 @Override
-                public OnSubscribe call(Observable o, OnSubscribe t) {
+                public Observable.OnSubscribe call(Observable o, Observable.OnSubscribe t) {
                     return new OnSubscribeRange(1, 2);
                 }
             });
@@ -400,7 +398,7 @@ public void singleCreate() {
                 public Single.OnSubscribe call(Single.OnSubscribe t) {
                     return new Single.OnSubscribe<Object>() {
                         @Override
-                        public void call(SingleSubscriber<Object> t) {
+                        public void call(SingleSubscriber<? super Object> t) {
                             t.onSuccess(10);
                         }
                     };
@@ -431,12 +429,12 @@ public void call(SingleSubscriber<Object> t) {
     @Test
     public void singleStart() {
         try {
-            RxJavaHooks.setOnSingleStart(new Func2<Single, OnSubscribe, OnSubscribe>() {
+            RxJavaHooks.setOnSingleStart(new Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe>() {
                 @Override
-                public OnSubscribe call(Single o, OnSubscribe t) {
-                    return new OnSubscribe<Object>() {
+                public Observable.OnSubscribe call(Single o, Observable.OnSubscribe t) {
+                    return new Observable.OnSubscribe<Object>() {
                         @Override
-                        public void call(Subscriber<Object> t) {
+                        public void call(Subscriber<? super Object> t) {
                             t.setProducer(new SingleProducer<Integer>(t, 10));
                         }
                     };
@@ -492,10 +490,10 @@ public Subscription call(Subscription t) {
     @Test
     public void completableCreate() {
         try {
-            RxJavaHooks.setOnCompletableCreate(new Func1<CompletableOnSubscribe, CompletableOnSubscribe>() {
+            RxJavaHooks.setOnCompletableCreate(new Func1<Completable.OnSubscribe, Completable.OnSubscribe>() {
                 @Override
-                public CompletableOnSubscribe call(CompletableOnSubscribe t) {
-                    return new CompletableOnSubscribe() {
+                public Completable.OnSubscribe call(Completable.OnSubscribe t) {
+                    return new Completable.OnSubscribe() {
                         @Override
                         public void call(CompletableSubscriber t) {
                             t.onError(new TestException());
@@ -527,10 +525,10 @@ public void call(CompletableSubscriber t) {
     @Test
     public void completableStart() {
         try {
-            RxJavaHooks.setOnCompletableStart(new Func2<Completable, CompletableOnSubscribe, CompletableOnSubscribe>() {
+            RxJavaHooks.setOnCompletableStart(new Func2<Completable, Completable.OnSubscribe, Completable.OnSubscribe>() {
                 @Override
-                public CompletableOnSubscribe call(Completable o, CompletableOnSubscribe t) {
-                    return new CompletableOnSubscribe() {
+                public Completable.OnSubscribe call(Completable o, Completable.OnSubscribe t) {
+                    return new Completable.OnSubscribe() {
                         @Override
                         public void call(CompletableSubscriber t) {
                             t.onError(new TestException());
@@ -772,7 +770,7 @@ public void call(Object t) {
             
             assertNull(RxJavaHooks.onCreate((Single.OnSubscribe)null));
 
-            Completable.CompletableOnSubscribe cos = new Completable.CompletableOnSubscribe() {
+            Completable.OnSubscribe cos = new Completable.OnSubscribe() {
                 @Override
                 public void call(CompletableSubscriber t) {
                     
@@ -839,7 +837,7 @@ public Object call(Object t) {
             
             assertSame(oop, RxJavaHooks.onSingleLift(oop));
             
-            Completable.CompletableOperator cop = new Completable.CompletableOperator() {
+            Completable.Operator cop = new Completable.Operator() {
                 @Override
                 public CompletableSubscriber call(CompletableSubscriber t) {
                     return t;
@@ -958,7 +956,7 @@ public Throwable onSubscribeError(Throwable e) {
     @Test
     public void onXLift() {
         try {
-            Completable.CompletableOperator cop = new Completable.CompletableOperator() {
+            Completable.Operator cop = new Completable.Operator() {
                 @Override
                 public CompletableSubscriber call(CompletableSubscriber t) {
                     return t;
@@ -974,25 +972,25 @@ public Object call(Object t) {
 
             final int[] counter = { 0 };
 
-            RxJavaHooks.setOnObservableLift(new Func1<Operator, Operator>() {
+            RxJavaHooks.setOnObservableLift(new Func1<Observable.Operator, Observable.Operator>() {
                 @Override
-                public Operator call(Operator t) {
+                public Observable.Operator call(Observable.Operator t) {
                     counter[0]++;
                     return t;
                 }
             });
 
-            RxJavaHooks.setOnSingleLift(new Func1<Operator, Operator>() {
+            RxJavaHooks.setOnSingleLift(new Func1<Observable.Operator, Observable.Operator>() {
                 @Override
-                public Operator call(Operator t) {
+                public Observable.Operator call(Observable.Operator t) {
                     counter[0]++;
                     return t;
                 }
             });
 
-            RxJavaHooks.setOnCompletableLift(new Func1<CompletableOperator, CompletableOperator>() {
+            RxJavaHooks.setOnCompletableLift(new Func1<Completable.Operator, Completable.Operator>() {
                 @Override
-                public CompletableOperator call(CompletableOperator t) {
+                public Completable.Operator call(Completable.Operator t) {
                     counter[0]++;
                     return t;
                 }
@@ -1019,7 +1017,7 @@ public void onPluginsXLift() {
             RxJavaPlugins.getInstance().reset();
             RxJavaHooks.reset();
 
-            Completable.CompletableOperator cop = new Completable.CompletableOperator() {
+            Completable.Operator cop = new Completable.Operator() {
                 @Override
                 public CompletableSubscriber call(CompletableSubscriber t) {
                     return t;
@@ -1035,17 +1033,17 @@ public Object call(Object t) {
 
             final int[] counter = { 0 };
 
-            final Func1<Operator, Operator> onObservableLift = new Func1<Operator, Operator>() {
+            final Func1<Observable.Operator, Observable.Operator> onObservableLift = new Func1<Observable.Operator, Observable.Operator>() {
                 @Override
-                public Operator call(Operator t) {
+                public Observable.Operator call(Observable.Operator t) {
                     counter[0]++;
                     return t;
                 }
             };
 
-            final Func1<CompletableOperator, CompletableOperator> onCompletableLift = new Func1<CompletableOperator, CompletableOperator>() {
+            final Func1<Completable.Operator, Completable.Operator> onCompletableLift = new Func1<Completable.Operator, Completable.Operator>() {
                 @Override
-                public CompletableOperator call(CompletableOperator t) {
+                public Completable.Operator call(Completable.Operator t) {
                     counter[0]++;
                     return t;
                 }
@@ -1053,21 +1051,21 @@ public CompletableOperator call(CompletableOperator t) {
             
             RxJavaPlugins.getInstance().registerObservableExecutionHook(new RxJavaObservableExecutionHook() {
                 @Override
-                public <T, R> Operator<? extends R, ? super T> onLift(Operator<? extends R, ? super T> lift) {
+                public <T, R> Observable.Operator<? extends R, ? super T> onLift(Observable.Operator<? extends R, ? super T> lift) {
                     return onObservableLift.call(lift);
                 }
             });
             
             RxJavaPlugins.getInstance().registerSingleExecutionHook(new RxJavaSingleExecutionHook() {
                 @Override
-                public <T, R> Operator<? extends R, ? super T> onLift(Operator<? extends R, ? super T> lift) {
+                public <T, R> Observable.Operator<? extends R, ? super T> onLift(Observable.Operator<? extends R, ? super T> lift) {
                     return onObservableLift.call(lift);
                 }
             });
             
             RxJavaPlugins.getInstance().registerCompletableExecutionHook(new RxJavaCompletableExecutionHook() {
                 @Override
-                public CompletableOperator onLift(CompletableOperator lift) {
+                public Completable.Operator onLift(Completable.Operator lift) {
                     return onCompletableLift.call(lift);
                 }
             });

From 0ee2e61aa43545a134d9bf210f92df76d3baa045 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 30 Aug 2016 15:59:39 +0200
Subject: [PATCH 159/263] 1.x: cleanup, javadoc, Completable.fromEmitter
 (#4442)

---
 src/main/java/rx/AsyncEmitter.java            |  23 +-
 src/main/java/rx/Completable.java             |  55 ++-
 src/main/java/rx/CompletableEmitter.java      |  64 ++++
 src/main/java/rx/Observable.java              |  52 ++-
 .../operators/CompletableFromEmitter.java     | 116 ++++++
 ...Async.java => OnSubscribeFromEmitter.java} |   9 +-
 .../internal/operators/OnSubscribeToMap.java  |   2 +
 .../operators/OnSubscribeToMultimap.java      |   3 +-
 .../rx/internal/schedulers/SchedulerWhen.java |   9 +-
 .../RxJavaCompletableExecutionHook.java       |  14 +-
 src/main/java/rx/plugins/RxJavaHooks.java     |   4 +-
 .../java/rx/ObservableConversionTest.java     |   1 +
 src/test/java/rx/ObservableTests.java         |   1 +
 src/test/java/rx/TestUtil.java                |  77 ++++
 .../operators/CompletableFromEmitterTest.java | 330 ++++++++++++++++++
 .../OnSubscribeConcatDelayErrorTest.java      |  16 -
 ...t.java => OnSubscribeFromEmitterTest.java} |  88 ++---
 .../OperatorToObservableSortedListTest.java   |   2 +-
 .../java/rx/schedulers/SchedulerWhenTest.java |   3 +-
 .../java/rx/subjects/ReplaySubjectTest.java   |  34 ++
 20 files changed, 815 insertions(+), 88 deletions(-)
 create mode 100644 src/main/java/rx/CompletableEmitter.java
 create mode 100644 src/main/java/rx/internal/operators/CompletableFromEmitter.java
 rename src/main/java/rx/internal/operators/{OnSubscribeFromAsync.java => OnSubscribeFromEmitter.java} (97%)
 create mode 100644 src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
 rename src/test/java/rx/internal/operators/{OnSubscribeFromAsyncTest.java => OnSubscribeFromEmitterTest.java} (80%)

diff --git a/src/main/java/rx/AsyncEmitter.java b/src/main/java/rx/AsyncEmitter.java
index 6235db4f60..aa577ada9d 100644
--- a/src/main/java/rx/AsyncEmitter.java
+++ b/src/main/java/rx/AsyncEmitter.java
@@ -28,6 +28,7 @@
  * other methods are threadsafe.
  *
  * @param <T> the value type to emit
+ * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
  */
 @Experimental
 public interface AsyncEmitter<T> extends Observer<T> {
@@ -69,14 +70,28 @@ interface Cancellable {
      * Options to handle backpressure in the emitter.
      */
     enum BackpressureMode {
+        /**
+         * No backpressure is applied an the onNext calls pass through the AsyncEmitter;
+         * note that this may cause {@link rx.exceptions.MissingBackpressureException} or {@link IllegalStateException}
+         * somewhere downstream.
+         */
         NONE,
-        
+        /**
+         * Signals a {@link rx.exceptions.MissingBackpressureException} if the downstream can't keep up.
+         */
         ERROR,
-        
+        /**
+         * Buffers (unbounded) all onNext calls until the dowsntream can consume them.
+         */
         BUFFER,
-        
+        /**
+         * Drops the incoming onNext value if the downstream can't keep up.
+         */
         DROP,
-        
+        /**
+         * Keeps the latest onNext value and overwrites it with newer ones until the downstream
+         * can consume it.
+         */
         LATEST
     }
 }
diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 474c6e7cdf..3ee09fd9bd 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -457,6 +457,9 @@ public static Completable concat(Observable<? extends Completable> sources, int
     }
 
     /**
+     * Constructs a Completable instance by wrapping the given old onSubscribe callback.
+     * @param onSubscribe the old CompletableOnSubscribe instance to wrap
+     * @return a Completable instance
      * @deprecated Use {@link #create(OnSubscribe)}.
      */
     @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
@@ -620,6 +623,44 @@ public void call(rx.CompletableSubscriber s) {
         });
     }
     
+    /**
+     * Provides an API (in a cold Completable) that bridges the Completable-reactive world
+     * with the callback-based world.
+     * <p>The {@link CompletableEmitter} allows registering a callback for
+     * cancellation/unsubscription of a resource.
+     * <p>
+     * Example:
+     * <pre><code>
+     * Completable.fromEmitter(emitter -&gt; {
+     *     Callback listener = new Callback() {
+     *         &#64;Override
+     *         public void onEvent(Event e) {
+     *             emitter.onCompleted();
+     *         }
+     *         
+     *         &#64;Override
+     *         public void onFailure(Exception e) {
+     *             emitter.onError(e);
+     *         }
+     *     };
+     *     
+     *     AutoCloseable c = api.someMethod(listener);
+     *     
+     *     emitter.setCancellation(c::close);
+     *     
+     * });
+     * </code></pre>
+     * <p>All of the CompletableEmitter's methods are thread-safe and ensure the 
+     * Completable's protocol are held.
+     * @param producer the callback invoked for each incoming CompletableSubscriber
+     * @return the new Completable instance
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public static Completable fromEmitter(Action1<CompletableEmitter> producer) {
+        return create(new CompletableFromEmitter(producer));
+    }
+    
     /**
      * Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.
      * <p>
@@ -1091,11 +1132,16 @@ protected Completable(CompletableOnSubscribe onSubscribe) {
      * not null (not verified)
      * @param useHook if false, RxJavaHooks.onCreate won't be called
      */
-    private Completable(OnSubscribe onSubscribe, boolean useHook) {
+    protected Completable(OnSubscribe onSubscribe, boolean useHook) {
         this.onSubscribe = useHook ? RxJavaHooks.onCreate(onSubscribe) : onSubscribe;
     }
 
     /**
+     * Constructs a Completable instance with the given onSubscribe callback without calling the onCreate
+     * hook.
+     * @param onSubscribe the callback that will receive CompletableSubscribers when they subscribe,
+     * not null (not verified)
+     * @param useHook if false, RxJavaHooks.onCreate won't be called
      * @deprecated Use {@link #Completable(OnSubscribe, boolean)}.
      */
     @Deprecated // TODO Remove constructor after 1.2.0 release. It was never a stable API. Provided only for migration.
@@ -1661,6 +1707,10 @@ public void onSubscribe(Subscription d) {
     }
 
     /**
+     * Lifts a CompletableSubscriber transformation into the chain of Completables.
+     * @param onLift the lifting function that transforms the child subscriber with a parent subscriber.
+     * @return the new Completable instance
+     * @throws NullPointerException if onLift is null
      * @deprecated Use {@link #lift(Operator)}.
      */
     @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
@@ -2132,6 +2182,9 @@ private static void deliverUncaughtException(Throwable e) {
     }
 
     /**
+     * Subscribes the given CompletableSubscriber to this Completable instance.
+     * @param s the CompletableSubscriber, not null
+     * @throws NullPointerException if s is null
      * @deprecated Use {@link #unsafeSubscribe(rx.CompletableSubscriber)}.
      */
     @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
diff --git a/src/main/java/rx/CompletableEmitter.java b/src/main/java/rx/CompletableEmitter.java
new file mode 100644
index 0000000000..a2e7ccc125
--- /dev/null
+++ b/src/main/java/rx/CompletableEmitter.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx;
+
+import rx.AsyncEmitter.Cancellable;
+import rx.annotations.Experimental;
+
+/**
+ * Abstraction over a {@link CompletableSubscriber} that gets either an onCompleted or onError
+ * signal and allows registering an cancellation/unsubscription callback.
+ * <p>
+ * All methods are thread-safe; calling onCompleted or onError twice or one after the other has
+ * no effect.
+ * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ */
+@Experimental
+public interface CompletableEmitter {
+
+    /**
+     * Notifies the CompletableSubscriber that the {@link Completable} has finished 
+     * sending push-based notifications.
+     * <p>
+     * The {@link Observable} will not call this method if it calls {@link #onError}.
+     */
+    void onCompleted();
+    
+    /**
+     * Notifies the CompletableSubscriber that the {@link Completable} has experienced an error condition.
+     * <p>
+     * If the {@link Completable} calls this method, it will not thereafter call
+     * {@link #onCompleted}.
+     * 
+     * @param t
+     *          the exception encountered by the Observable
+     */
+    void onError(Throwable t);
+
+    /**
+     * Sets a Subscription on this emitter; any previous Subscription
+     * or Cancellation will be unsubscribed/cancelled.
+     * @param s the subscription, null is allowed
+     */
+    void setSubscription(Subscription s);
+    
+    /**
+     * Sets a Cancellable on this emitter; any previous Subscription
+     * or Cancellation will be unsubscribed/cancelled.
+     * @param c the cancellable resource, null is allowed
+     */
+    void setCancellation(Cancellable c);
+}
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index ed83037e07..e1e25cf172 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -2007,7 +2007,7 @@ public static <T> Observable<T> from(T[] array) {
      *     
      *     AutoCloseable c = api.someMethod(listener);
      *     
-     *     emitter.setCancellable(c::close);
+     *     emitter.setCancellation(c::close);
      *     
      * }, BackpressureMode.BUFFER);
      * </code></pre>
@@ -2022,10 +2022,58 @@ public static <T> Observable<T> from(T[] array) {
      * @see AsyncEmitter
      * @see AsyncEmitter.BackpressureMode
      * @see AsyncEmitter.Cancellable
+     * @deprecated renamed, use {@link #fromEmitter(Action1, rx.AsyncEmitter.BackpressureMode)} instead
      */
     @Experimental
+    @Deprecated // will be removed in 1.2.0
     public static <T> Observable<T> fromAsync(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) {
-        return create(new OnSubscribeFromAsync<T>(asyncEmitter, backpressure));
+        return fromEmitter(asyncEmitter, backpressure);
+    }
+    
+    /**
+     * Provides an API (via a cold Observable) that bridges the reactive world with the callback-style,
+     * generally non-backpressured world.
+     * <p>
+     * Example:
+     * <pre><code>
+     * Observable.&lt;Event&gt;fromEmitter(emitter -&gt; {
+     *     Callback listener = new Callback() {
+     *         &#64;Override
+     *         public void onEvent(Event e) {
+     *             emitter.onNext(e);
+     *             if (e.isLast()) {
+     *                 emitter.onCompleted();
+     *             }
+     *         }
+     *         
+     *         &#64;Override
+     *         public void onFailure(Exception e) {
+     *             emitter.onError(e);
+     *         }
+     *     };
+     *     
+     *     AutoCloseable c = api.someMethod(listener);
+     *     
+     *     emitter.setCancellation(c::close);
+     *     
+     * }, BackpressureMode.BUFFER);
+     * </code></pre>
+     * <p>
+     * You should call the AsyncEmitter's onNext, onError and onCompleted methods in a serialized fashion. The
+     * rest of its methods are threadsafe.
+     * 
+     * @param <T> the element type
+     * @param emitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
+     * @param backpressure the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
+     * @return the new Observable instance
+     * @see AsyncEmitter
+     * @see AsyncEmitter.BackpressureMode
+     * @see AsyncEmitter.Cancellable
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public static <T> Observable<T> fromEmitter(Action1<AsyncEmitter<T>> emitter, AsyncEmitter.BackpressureMode backpressure) {
+        return create(new OnSubscribeFromEmitter<T>(emitter, backpressure));
     }
     
     /**
diff --git a/src/main/java/rx/internal/operators/CompletableFromEmitter.java b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
new file mode 100644
index 0000000000..ac94a1ae94
--- /dev/null
+++ b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import rx.*;
+import rx.AsyncEmitter.Cancellable;
+import rx.exceptions.Exceptions;
+import rx.functions.Action1;
+import rx.internal.operators.OnSubscribeFromEmitter.CancellableSubscription;
+import rx.internal.subscriptions.SequentialSubscription;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Allows push-based emission of terminal events to a CompletableSubscriber.
+ */
+public final class CompletableFromEmitter implements Completable.OnSubscribe {
+
+    final Action1<CompletableEmitter> producer;
+
+    public CompletableFromEmitter(Action1<CompletableEmitter> producer) {
+        this.producer = producer;
+    }
+    
+    @Override
+    public void call(CompletableSubscriber t) {
+        FromEmitter emitter = new FromEmitter(t);
+        t.onSubscribe(emitter);
+        
+        try {
+            producer.call(emitter);
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            emitter.onError(ex);
+        }
+        
+    }
+    
+    static final class FromEmitter 
+    extends AtomicBoolean
+    implements CompletableEmitter, Subscription {
+
+        /** */
+        private static final long serialVersionUID = 5539301318568668881L;
+
+        final CompletableSubscriber actual;
+        
+        final SequentialSubscription resource;
+        
+        public FromEmitter(CompletableSubscriber actual) {
+            this.actual = actual;
+            resource = new SequentialSubscription();
+        }
+        
+        @Override
+        public void onCompleted() {
+            if (compareAndSet(false, true)) {
+                try {
+                    actual.onCompleted();
+                } finally {
+                    resource.unsubscribe();
+                }
+            }
+        }
+
+        @Override
+        public void onError(Throwable t) {
+            if (compareAndSet(false, true)) {
+                try {
+                    actual.onError(t);
+                } finally {
+                    resource.unsubscribe();
+                }
+            } else {
+                RxJavaHooks.onError(t);
+            }
+        }
+
+        @Override
+        public void setSubscription(Subscription s) {
+            resource.update(s);
+        }
+
+        @Override
+        public void setCancellation(Cancellable c) {
+            setSubscription(new CancellableSubscription(c));
+        }
+
+        @Override
+        public void unsubscribe() {
+            if (compareAndSet(false, true)) {
+                resource.unsubscribe();
+            }
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return get();
+        }
+        
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromAsync.java b/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
similarity index 97%
rename from src/main/java/rx/internal/operators/OnSubscribeFromAsync.java
rename to src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
index b5d57b8135..a911a9d09d 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromAsync.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
@@ -28,13 +28,13 @@
 import rx.plugins.RxJavaHooks;
 import rx.subscriptions.SerialSubscription;
 
-public final class OnSubscribeFromAsync<T> implements OnSubscribe<T> {
+public final class OnSubscribeFromEmitter<T> implements OnSubscribe<T> {
 
     final Action1<AsyncEmitter<T>> asyncEmitter;
     
     final AsyncEmitter.BackpressureMode backpressure;
     
-    public OnSubscribeFromAsync(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) {
+    public OnSubscribeFromEmitter(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) {
         this.asyncEmitter = asyncEmitter;
         this.backpressure = backpressure;
     }
@@ -72,6 +72,9 @@ public void call(Subscriber<? super T> t) {
         
     }
     
+    /**
+     * A Subscription that wraps an AsyncEmitter.Cancellable instance.
+     */
     static final class CancellableSubscription 
     extends AtomicReference<AsyncEmitter.Cancellable>
     implements Subscription {
@@ -299,7 +302,7 @@ public void onError(Throwable e) {
 
         @Override
         void onOverflow() {
-            onError(new MissingBackpressureException("fromAsync: could not emit value due to lack of requests"));
+            onError(new MissingBackpressureException("fromEmitter: could not emit value due to lack of requests"));
         }
         
     }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeToMap.java b/src/main/java/rx/internal/operators/OnSubscribeToMap.java
index a15014e1f3..6b254c172e 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeToMap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeToMap.java
@@ -47,6 +47,7 @@ public final class OnSubscribeToMap<T, K, V> implements OnSubscribe<Map<K, V>>,
 
     /**
      * ToMap with key selector, value selector and default HashMap factory.
+     * @param source the source Observable instance
      * @param keySelector the function extracting the map-key from the main value
      * @param valueSelector the function extracting the map-value from the main value
      */
@@ -59,6 +60,7 @@ public OnSubscribeToMap(Observable<T> source,
 
     /**
      * ToMap with key selector, value selector and custom Map factory.
+     * @param source the source Observable instance
      * @param keySelector the function extracting the map-key from the main value
      * @param valueSelector the function extracting the map-value from the main value
      * @param mapFactory function that returns a Map instance to store keys and values into
diff --git a/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java b/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
index 04db4b4f02..f8c8b42e05 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
@@ -49,6 +49,7 @@ public final class OnSubscribeToMultimap<T, K, V> implements OnSubscribe<Map<K,
     /**
      * ToMultimap with key selector, custom value selector,
      * default HashMap factory and default ArrayList collection factory.
+     * @param source the source Observable instance
      * @param keySelector the function extracting the map-key from the main value
      * @param valueSelector the function extracting the map-value from the main value
      */
@@ -64,7 +65,7 @@ public OnSubscribeToMultimap(
     /**
      * ToMultimap with key selector, custom value selector,
      * custom Map factory and default ArrayList collection factory.
-     * @param the observable source
+     * @param source the source Observable instance
      * @param keySelector the function extracting the map-key from the main value
      * @param valueSelector the function extracting the map-value from the main value
      * @param mapFactory function that returns a Map instance to store keys and values into
diff --git a/src/main/java/rx/internal/schedulers/SchedulerWhen.java b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
index 16a5f3dcda..b53e1ca10e 100644
--- a/src/main/java/rx/internal/schedulers/SchedulerWhen.java
+++ b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
@@ -53,7 +53,7 @@
  * Finally the actions scheduled on the parent {@link Scheduler} when the inner
  * most {@link Completable}s are subscribed to.
  * <p>
- * When the {@link Worker} is unsubscribed the {@link Completable} emits an
+ * When the {@link rx.Scheduler.Worker} is unsubscribed the {@link Completable} emits an
  * onComplete and triggers any behavior in the flattening operator. The
  * {@link Observable} and all {@link Completable}s give to the flattening
  * function never onError.
@@ -71,8 +71,8 @@
  * <p>
  * This is a slightly different way to limit the concurrency but it has some
  * interesting benefits and drawbacks to the method above. It works by limited
- * the number of concurrent {@link Worker}s rather than individual actions.
- * Generally each {@link Observable} uses its own {@link Worker}. This means
+ * the number of concurrent {@link rx.Scheduler.Worker}s rather than individual actions.
+ * Generally each {@link Observable} uses its own {@link rx.Scheduler.Worker}. This means
  * that this will essentially limit the number of concurrent subscribes. The
  * danger comes from using operators like
  * {@link Observable#zip(Observable, Observable, rx.functions.Func2)} where
@@ -101,9 +101,6 @@
  * 	}));
  * });
  * </pre>
- * 
- * @param combine
- * @return
  */
 @Experimental
 public class SchedulerWhen extends Scheduler implements Subscription {
diff --git a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
index b4596655cf..5400ef8b63 100644
--- a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
@@ -46,8 +46,8 @@ public abstract class RxJavaCompletableExecutionHook { // NOPMD
      * logging, metrics and other such things and pass through the function.
      *
      * @param f
-     *            original {@link Completable.OnSubscribe}<{@code T}> to be executed
-     * @return {@link Completable.OnSubscribe} function that can be modified, decorated, replaced or just
+     *            original {@link rx.Completable.OnSubscribe}<{@code T}> to be executed
+     * @return {@link rx.Completable.OnSubscribe} function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
     @Deprecated
@@ -63,8 +63,8 @@ public Completable.OnSubscribe onCreate(Completable.OnSubscribe f) {
      *
      * @param completableInstance the target completable instance
      * @param onSubscribe
-     *            original {@link Completable.OnSubscribe}<{@code T}> to be executed
-     * @return {@link Completable.OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
+     *            original {@link rx.Completable.OnSubscribe}<{@code T}> to be executed
+     * @return {@link rx.Completable.OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
     @Deprecated
@@ -93,12 +93,12 @@ public Throwable onSubscribeError(Throwable e) {
      * Invoked just as the operator functions is called to bind two operations together into a new
      * {@link Completable} and the return value is used as the lifted function
      * <p>
-     * This can be used to decorate or replace the {@link Completable.Operator} instance or just perform extra
+     * This can be used to decorate or replace the {@link rx.Completable.Operator} instance or just perform extra
      * logging, metrics and other such things and pass through the onSubscribe.
      *
      * @param lift
-     *            original {@link Completable.Operator}{@code <R, T>}
-     * @return {@link Completable.Operator}{@code <R, T>} function that can be modified, decorated, replaced or just
+     *            original {@link rx.Completable.Operator}{@code <R, T>}
+     * @return {@link rx.Completable.Operator}{@code <R, T>} function that can be modified, decorated, replaced or just
      *         returned as a pass through
      */
     @Deprecated
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index d438987400..61ad3c69c2 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -421,7 +421,7 @@ public static Action0 onScheduledAction(Action0 action) {
      * @return the original or alternative action that will be subscribed to
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
-    public static <T> Observable.OnSubscribe onObservableStart(Observable<T> instance, Observable.OnSubscribe onSubscribe) {
+    public static <T> Observable.OnSubscribe<T> onObservableStart(Observable<T> instance, Observable.OnSubscribe<T> onSubscribe) {
         Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableStart;
         if (f != null) {
             return f.call(instance, onSubscribe);
@@ -479,7 +479,7 @@ public static <T, R> Observable.Operator<R, T> onObservableLift(Observable.Opera
      * @return the original or alternative action that will be subscribed to
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
-    public static <T> Observable.OnSubscribe onSingleStart(Single<T> instance, Observable.OnSubscribe onSubscribe) {
+    public static <T> Observable.OnSubscribe<T> onSingleStart(Single<T> instance, Observable.OnSubscribe<T> onSubscribe) {
         Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> f = onSingleStart;
         if (f != null) {
             return f.call(instance, onSubscribe);
diff --git a/src/test/java/rx/ObservableConversionTest.java b/src/test/java/rx/ObservableConversionTest.java
index b90132fed7..6e0e0e1c23 100644
--- a/src/test/java/rx/ObservableConversionTest.java
+++ b/src/test/java/rx/ObservableConversionTest.java
@@ -36,6 +36,7 @@
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 
+@SuppressWarnings("deprecation")
 public class ObservableConversionTest {
     
     public static class Cylon {}
diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
index 16443d4476..115fe34735 100644
--- a/src/test/java/rx/ObservableTests.java
+++ b/src/test/java/rx/ObservableTests.java
@@ -1107,6 +1107,7 @@ public void testForEachWithNull() {
         .forEach(null);
     }
     
+    @SuppressWarnings("deprecation")
     @Test
     public void testExtend() {
         final TestSubscriber<Object> subscriber = new TestSubscriber<Object>();
diff --git a/src/test/java/rx/TestUtil.java b/src/test/java/rx/TestUtil.java
index 4e315370f7..5d60c4758f 100644
--- a/src/test/java/rx/TestUtil.java
+++ b/src/test/java/rx/TestUtil.java
@@ -16,8 +16,17 @@
 
 package rx;
 
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
 import com.pushtorefresh.private_constructor_checker.PrivateConstructorChecker;
 
+import rx.Scheduler.Worker;
+import rx.exceptions.Exceptions;
+import rx.functions.Action0;
+import rx.schedulers.Schedulers;
+
 /**
  * Common test utility methods.
  */
@@ -36,4 +45,72 @@ public static void checkUtilityClass(Class<?> clazz) {
             .expectedExceptionMessage("No instances!")
             .check();
     }
+    
+    /**
+     * Runs two actions concurrently, one in the current thread and the other on
+     * the IO scheduler, synchronizing their execution as much as possible; rethrowing
+     * any exceptions they produce.
+     * <p>This helper waits until both actions have run or times out in 5 seconds.
+     * @param r1 the first action
+     * @param r2 the second action
+     */
+    public static void race(Action0 r1, final Action0 r2) {
+        final AtomicInteger counter = new AtomicInteger(2);
+        final Throwable[] errors = { null, null };
+        final CountDownLatch cdl = new CountDownLatch(1);
+        
+        Worker w = Schedulers.io().createWorker();
+        
+        try {
+            
+            w.schedule(new Action0() {
+                @Override
+                public void call() {
+                    if (counter.decrementAndGet() != 0) {
+                        while (counter.get() != 0);
+                    }
+                    
+                    try {
+                        r2.call();
+                    } catch (Throwable ex) {
+                        errors[1] = ex;
+                    }
+                    
+                    cdl.countDown();
+                }
+            });
+
+            if (counter.decrementAndGet() != 0) {
+                while (counter.get() != 0);
+            }
+            
+            try {
+                r1.call();
+            } catch (Throwable ex) {
+                errors[0] = ex;
+            }
+            
+            List<Throwable> errorList = new ArrayList<Throwable>();
+            
+            try {
+                if (!cdl.await(5, TimeUnit.SECONDS)) {
+                    errorList.add(new TimeoutException());
+                }
+            } catch (InterruptedException ex) {
+                errorList.add(ex);
+            }
+            
+            if (errors[0] != null) {
+                errorList.add(errors[0]);
+            }
+
+            if (errors[1] != null) {
+                errorList.add(errors[1]);
+            }
+
+            Exceptions.throwIfAny(errorList);
+        } finally {
+            w.unsubscribe();
+        }
+    }
 }
diff --git a/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java b/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
new file mode 100644
index 0000000000..d7ef2c3217
--- /dev/null
+++ b/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
@@ -0,0 +1,330 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import static org.junit.Assert.*;
+
+import java.io.IOException;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import rx.*;
+import rx.exceptions.TestException;
+import rx.functions.*;
+import rx.observers.TestSubscriber;
+import rx.subscriptions.BooleanSubscription;
+
+public class CompletableFromEmitterTest {
+
+    @Test
+    public void normal() {
+        TestSubscriber<Void> ts = TestSubscriber.create();
+        
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                e.onCompleted();
+            }
+        }).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void error() {
+        TestSubscriber<Void> ts = TestSubscriber.create();
+        
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                e.onError(new TestException());
+            }
+        }).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+    
+    @Test
+    public void ensureProtocol1() { 
+        TestSubscriber<Void> ts = TestSubscriber.create();
+        
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                e.onError(new TestException());
+                e.onCompleted();
+                e.onError(new IOException());
+            }
+        }).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void ensureProtocol2() { 
+        TestSubscriber<Void> ts = TestSubscriber.create();
+        
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                e.onCompleted();
+                e.onError(new TestException());
+                e.onCompleted();
+            }
+        }).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void resourceCleanupNormal() {
+        TestSubscriber<Void> ts = TestSubscriber.create();
+
+        final BooleanSubscription bs = new BooleanSubscription();
+
+        assertFalse(bs.isUnsubscribed());
+
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                e.setSubscription(bs);
+                e.onCompleted();
+            }
+        }).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        
+        assertTrue(bs.isUnsubscribed());
+    }
+    
+    @Test
+    public void resourceCleanupError() {
+        TestSubscriber<Void> ts = TestSubscriber.create();
+
+        final BooleanSubscription bs = new BooleanSubscription();
+
+        assertFalse(bs.isUnsubscribed());
+
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                e.setSubscription(bs);
+                e.onError(new TestException());
+            }
+        }).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+        
+        assertTrue(bs.isUnsubscribed());
+    }
+    
+    @Test
+    public void resourceCleanupCancellable() throws Exception {
+        TestSubscriber<Void> ts = TestSubscriber.create();
+
+        final AsyncEmitter.Cancellable c = Mockito.mock(AsyncEmitter.Cancellable.class);
+
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                e.setCancellation(c);
+                e.onCompleted();
+            }
+        }).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+
+        Mockito.verify(c).cancel();
+    }
+    
+    @Test
+    public void resourceCleanupUnsubscirbe() throws Exception {
+        TestSubscriber<Void> ts = TestSubscriber.create();
+        ts.unsubscribe();
+
+        final AsyncEmitter.Cancellable c = Mockito.mock(AsyncEmitter.Cancellable.class);
+
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                e.setCancellation(c);
+                e.onCompleted();
+            }
+        }).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+
+        Mockito.verify(c).cancel();
+    }
+    
+    @Test
+    public void resourceCleanupOnCompleteCrashes() throws Exception {
+        final AsyncEmitter.Cancellable c = Mockito.mock(AsyncEmitter.Cancellable.class);
+
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                e.setCancellation(c);
+                e.onCompleted();
+            }
+        }).unsafeSubscribe(new CompletableSubscriber() {
+
+            @Override
+            public void onCompleted() {
+                throw new TestException();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                throw new TestException();
+            }
+
+            @Override
+            public void onSubscribe(Subscription d) {
+                
+            }
+            
+        });
+        
+
+        Mockito.verify(c).cancel();
+    }
+    
+    @Test
+    public void resourceCleanupOnErrorCrashes() throws Exception {
+        final AsyncEmitter.Cancellable c = Mockito.mock(AsyncEmitter.Cancellable.class);
+
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                e.setCancellation(c);
+                e.onError(new IOException());
+            }
+        }).unsafeSubscribe(new CompletableSubscriber() {
+
+            @Override
+            public void onCompleted() {
+                throw new TestException();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                throw new TestException();
+            }
+
+            @Override
+            public void onSubscribe(Subscription d) {
+                
+            }
+            
+        });
+        
+
+        Mockito.verify(c).cancel();
+    }
+    @Test
+    public void producerCrashes() {
+        TestSubscriber<Void> ts = TestSubscriber.create();
+        
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                throw new TestException();
+            }
+        }).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void producerCrashesAfterSignal() {
+        TestSubscriber<Void> ts = TestSubscriber.create();
+        
+        Completable.fromEmitter(new Action1<CompletableEmitter>() {
+            @Override
+            public void call(CompletableEmitter e) {
+                e.onCompleted();
+                throw new TestException();
+            }
+        }).subscribe(ts);
+        
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+    
+    @Test
+    public void concurrentUse() {
+        for (int i = 0; i < 500; i++) {
+            TestSubscriber<Void> ts = TestSubscriber.create();
+            
+            final CompletableEmitter[] emitter = { null };
+            
+            Completable.fromEmitter(new Action1<CompletableEmitter>() {
+                @Override
+                public void call(CompletableEmitter e) {
+                    emitter[0] = e;
+                }
+            }).subscribe(ts);
+            
+            final TestException ex = new TestException();
+            final CompletableEmitter e = emitter[0];
+            
+            TestUtil.race(new Action0() {
+                @Override
+                public void call() { 
+                    e.onCompleted();
+                }
+            }, new Action0() {
+                @Override
+                public void call() { 
+                    e.onError(ex);
+                }
+            });
+            
+            if (ts.getCompletions() != 0) {
+                ts.assertNoValues();
+                ts.assertNoErrors();
+                ts.assertCompleted();
+            }
+            if (!ts.getOnErrorEvents().isEmpty()) {
+                ts.assertNoValues();
+                ts.assertError(ex);
+                ts.assertNotCompleted();
+            }
+        }
+    }
+}
diff --git a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
index ee768ffc1a..749fa975ea 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
@@ -277,7 +277,6 @@ public void concatDelayErrorIterableError() {
         assertEquals(2, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError2() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -292,7 +291,6 @@ public void concatDelayError2() {
         ts.assertCompleted();
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError2Error() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -309,7 +307,6 @@ public void concatDelayError2Error() {
         assertEquals(2, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError3() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -325,7 +322,6 @@ public void concatDelayError3() {
         ts.assertCompleted();
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError3Error() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -343,7 +339,6 @@ public void concatDelayError3Error() {
         assertEquals(3, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError4() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -360,7 +355,6 @@ public void concatDelayError4() {
         ts.assertCompleted();
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError4Error() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -379,7 +373,6 @@ public void concatDelayError4Error() {
         assertEquals(4, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError5() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -397,7 +390,6 @@ public void concatDelayError5() {
         ts.assertCompleted();
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError5Error() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -417,7 +409,6 @@ public void concatDelayError5Error() {
         assertEquals(5, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError6() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -436,7 +427,6 @@ public void concatDelayError6() {
         ts.assertCompleted();
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError6Error() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -457,7 +447,6 @@ public void concatDelayError6Error() {
         assertEquals(6, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError7() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -477,7 +466,6 @@ public void concatDelayError7() {
         ts.assertCompleted();
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError7Error() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -499,7 +487,6 @@ public void concatDelayError7Error() {
         assertEquals(7, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError8() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -521,7 +508,6 @@ public void concatDelayError8() {
         ts.assertCompleted();
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError8Error() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -544,7 +530,6 @@ public void concatDelayError8Error() {
         assertEquals(8, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError9() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -567,7 +552,6 @@ public void concatDelayError9() {
         ts.assertCompleted();
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     public void concatDelayError9Error() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromAsyncTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
similarity index 80%
rename from src/test/java/rx/internal/operators/OnSubscribeFromAsyncTest.java
rename to src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
index bc6587ac0d..2579bc9528 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromAsyncTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
@@ -31,7 +31,7 @@
 import rx.plugins.RxJavaHooks;
 import rx.subjects.PublishSubject;
 
-public class OnSubscribeFromAsyncTest {
+public class OnSubscribeFromEmitterTest {
 
     PublishAsyncEmitter source;
 
@@ -48,7 +48,7 @@ public void before() {
     
     @Test
     public void normalBuffered() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         
         source.onNext(1);
         source.onNext(2);
@@ -69,7 +69,7 @@ public void normalBuffered() {
 
     @Test
     public void normalDrop() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
         
         source.onNext(1);
 
@@ -85,7 +85,7 @@ public void normalDrop() {
 
     @Test
     public void normalLatest() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
         
         source.onNext(1);
 
@@ -101,7 +101,7 @@ public void normalLatest() {
 
     @Test
     public void normalNone() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
         
         source.onNext(1);
         source.onNext(2);
@@ -114,7 +114,7 @@ public void normalNone() {
 
     @Test
     public void normalNoneRequested() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
         ts.requestMore(2);
         
         source.onNext(1);
@@ -129,7 +129,7 @@ public void normalNoneRequested() {
 
     @Test
     public void normalError() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
         
         source.onNext(1);
         source.onNext(2);
@@ -139,7 +139,7 @@ public void normalError() {
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
         
-        Assert.assertEquals("fromAsync: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
     }
     
     @Test
@@ -152,13 +152,13 @@ public void call(AsyncEmitter<Integer> emitter) {
                 //don't check for unsubscription
                 emitter.onNext(2);
             }};
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
         
         ts.assertNoValues();
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
         
-        Assert.assertEquals("fromAsync: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
     }
     
     @Test
@@ -171,13 +171,13 @@ public void call(AsyncEmitter<Integer> emitter) {
                 //don't check for unsubscription
                 emitter.onCompleted();
             }};
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
         
         ts.assertNoValues();
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
         
-        Assert.assertEquals("fromAsync: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
     }
     
     @Test
@@ -198,13 +198,13 @@ public void call(AsyncEmitter<Integer> emitter) {
                     //don't check for unsubscription
                     emitter.onError(e);
                 }};
-            Observable.fromAsync(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+            Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
             
             ts.assertNoValues();
             ts.assertError(MissingBackpressureException.class);
             ts.assertNotCompleted();
             
-            Assert.assertEquals("fromAsync: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+            Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
             assertEquals(Arrays.asList(e), list);
         } finally {
             RxJavaHooks.reset();
@@ -213,7 +213,7 @@ public void call(AsyncEmitter<Integer> emitter) {
 
     @Test
     public void errorBuffered() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         
         source.onNext(1);
         source.onNext(2);
@@ -232,7 +232,7 @@ public void errorBuffered() {
 
     @Test
     public void errorLatest() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
         
         source.onNext(1);
         source.onNext(2);
@@ -247,7 +247,7 @@ public void errorLatest() {
     
     @Test
     public void errorNone() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
         
         source.onNext(1);
         source.onNext(2);
@@ -262,7 +262,7 @@ public void errorNone() {
 
     @Test
     public void unsubscribedBuffer() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.unsubscribe();
         
         source.onNext(1);
@@ -278,7 +278,7 @@ public void unsubscribedBuffer() {
 
     @Test
     public void unsubscribedLatest() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
         ts.unsubscribe();
         
         source.onNext(1);
@@ -294,7 +294,7 @@ public void unsubscribedLatest() {
 
     @Test
     public void unsubscribedError() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
         ts.unsubscribe();
         
         source.onNext(1);
@@ -310,7 +310,7 @@ public void unsubscribedError() {
 
     @Test
     public void unsubscribedDrop() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
         ts.unsubscribe();
         
         source.onNext(1);
@@ -326,7 +326,7 @@ public void unsubscribedDrop() {
 
     @Test
     public void unsubscribedNone() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
         ts.unsubscribe();
         
         source.onNext(1);
@@ -342,7 +342,7 @@ public void unsubscribedNone() {
 
     @Test
     public void unsubscribedNoCancelBuffer() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.unsubscribe();
         
         sourceNoCancel.onNext(1);
@@ -358,7 +358,7 @@ public void unsubscribedNoCancelBuffer() {
 
     @Test
     public void unsubscribedNoCancelLatest() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
         ts.unsubscribe();
         
         sourceNoCancel.onNext(1);
@@ -374,7 +374,7 @@ public void unsubscribedNoCancelLatest() {
 
     @Test
     public void unsubscribedNoCancelError() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
         ts.unsubscribe();
         
         sourceNoCancel.onNext(1);
@@ -390,7 +390,7 @@ public void unsubscribedNoCancelError() {
 
     @Test
     public void unsubscribedNoCancelDrop() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
         ts.unsubscribe();
         
         sourceNoCancel.onNext(1);
@@ -406,7 +406,7 @@ public void unsubscribedNoCancelDrop() {
 
     @Test
     public void unsubscribedNoCancelNone() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
         ts.unsubscribe();
         
         sourceNoCancel.onNext(1);
@@ -422,7 +422,7 @@ public void unsubscribedNoCancelNone() {
 
     @Test
     public void deferredRequest() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         
         source.onNext(1);
         source.onNext(2);
@@ -437,7 +437,7 @@ public void deferredRequest() {
 
     @Test
     public void take() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
         
         source.onNext(1);
         source.onNext(2);
@@ -452,7 +452,7 @@ public void take() {
 
     @Test
     public void takeOne() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
         ts.requestMore(2);
         
         source.onNext(1);
@@ -466,7 +466,7 @@ public void takeOne() {
 
     @Test
     public void requestExact() {
-        Observable.fromAsync(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.requestMore(2);
         
         source.onNext(1);
@@ -480,7 +480,7 @@ public void requestExact() {
 
     @Test
     public void takeNoCancel() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
         
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
@@ -495,7 +495,7 @@ public void takeNoCancel() {
 
     @Test
     public void takeOneNoCancel() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
         ts.requestMore(2);
         
         sourceNoCancel.onNext(1);
@@ -509,7 +509,7 @@ public void takeOneNoCancel() {
 
     @Test
     public void unsubscribeNoCancel() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.requestMore(2);
         
         sourceNoCancel.onNext(1);
@@ -534,7 +534,7 @@ public void onNext(Integer t) {
             }
         };
         
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
         
         sourceNoCancel.onNext(1);
         
@@ -545,7 +545,7 @@ public void onNext(Integer t) {
 
     @Test
     public void completeInline() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
@@ -559,7 +559,7 @@ public void completeInline() {
 
     @Test
     public void errorInline() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         
         sourceNoCancel.onNext(1);
         sourceNoCancel.onError(new TestException());
@@ -581,7 +581,7 @@ public void onNext(Integer t) {
             }
         };
         
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
         
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
@@ -601,7 +601,7 @@ public void onNext(Integer t) {
             }
         };
         
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
         
         sourceNoCancel.onNext(1);
         
@@ -620,7 +620,7 @@ public void onNext(Integer t) {
             }
         };
         
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
         
         sourceNoCancel.onNext(1);
         
@@ -631,7 +631,7 @@ public void onNext(Integer t) {
 
     @Test
     public void completeInlineLatest() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
         
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
@@ -645,7 +645,7 @@ public void completeInlineLatest() {
 
     @Test
     public void completeInlineExactLatest() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
         
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
@@ -659,7 +659,7 @@ public void completeInlineExactLatest() {
 
     @Test
     public void errorInlineLatest() {
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
         
         sourceNoCancel.onNext(1);
         sourceNoCancel.onError(new TestException());
@@ -681,7 +681,7 @@ public void onNext(Integer t) {
             }
         };
         
-        Observable.fromAsync(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
         
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
diff --git a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
index 6fa3b40647..e679748f85 100644
--- a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
+++ b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
@@ -259,7 +259,7 @@ public void testSortedWithNonComparable() {
         testSubscriber.assertNotCompleted();
     }
 
-    private final static class NonComparable{
+    final static class NonComparable{
         public int i;
         public String s;
 
diff --git a/src/test/java/rx/schedulers/SchedulerWhenTest.java b/src/test/java/rx/schedulers/SchedulerWhenTest.java
index f911e0d10a..c6c3386d04 100644
--- a/src/test/java/rx/schedulers/SchedulerWhenTest.java
+++ b/src/test/java/rx/schedulers/SchedulerWhenTest.java
@@ -195,7 +195,8 @@ public Completable call(Observable<Completable> actions) {
 					}
 				});
 				return Completable.concat(workers.map(new Func1<Completable, Completable>() {
-					public Completable call(Completable worker) {
+					@Override
+				    public Completable call(Completable worker) {
 						return worker.delay(1, SECONDS, tSched);
 					}
 				}));
diff --git a/src/test/java/rx/subjects/ReplaySubjectTest.java b/src/test/java/rx/subjects/ReplaySubjectTest.java
index 50e1702869..de2db7846b 100644
--- a/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -1140,5 +1140,39 @@ public void backpressureSizeAndTimeOffline() {
         backpressureOffline(ReplaySubject.<Integer>createWithTimeAndSize(1, TimeUnit.DAYS, 10, Schedulers.immediate()));
         backpressureOffline(ReplaySubject.<Integer>createWithTimeAndSize(1, TimeUnit.DAYS, 100, Schedulers.immediate()));
     }
+    
+    @Test
+    public void filtered() {
+        ReplaySubject<Integer> subject = ReplaySubject.create();
+        
+        TestSubscriber<Integer> ts1 = TestSubscriber.create();
+        TestSubscriber<Integer> ts2 = TestSubscriber.create();
+        
+        Observable<Integer> o = subject.filter(new Func1<Integer, Boolean>() {
+            @Override
+            public Boolean call(Integer v) {
+                return v > 0;
+            }
+        });
+        
+        o.subscribe(ts1);
+        o.subscribe(ts2);
+        
+        subject.onNext(1);
+        subject.onNext(2);
+        subject.onNext(0);
+        subject.onNext(3);
+        subject.onNext(0);
+        subject.onNext(6);
+        
+        ts1.assertValues(1, 2, 3, 6);
+        ts2.assertValues(1, 2, 3, 6);
+        
+        subject.onNext(0);
+        subject.onNext(7);
+        
+        ts1.assertValues(1, 2, 3, 6, 7);
+        ts2.assertValues(1, 2, 3, 6, 7);
+    }
 
 }

From c9086ebb863910b4ca3f617f117a11e0f1fc9ac1 Mon Sep 17 00:00:00 2001
From: Shixiong Zhu <zsxwing@gmail.com>
Date: Tue, 30 Aug 2016 20:09:19 -0700
Subject: [PATCH 160/263] Fix withLatestFrom's tparam

---
 src/main/java/rx/Observable.java | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index e1e25cf172..b4104c3e3a 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -12040,8 +12040,8 @@ public final <T1, T2, T3, T4, R> Observable<R> withLatestFrom(
     @Experimental
     public final <T1, T2, T3, T4, T5, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2, 
-            Observable<T1> o3, Observable<T2> o4, 
-            Observable<T1> o5, 
+            Observable<T3> o3, Observable<T4> o4,
+            Observable<T5> o5,
             Func6<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, R> combiner) {
         return create(new OperatorWithLatestFromMany<T, R>(this, 
                 new Observable<?>[] { o1, o2, o3, o4, o5 }, null, Functions.fromFunc(combiner)));
@@ -12085,8 +12085,8 @@ public final <T1, T2, T3, T4, T5, R> Observable<R> withLatestFrom(
     @Experimental
     public final <T1, T2, T3, T4, T5, T6, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2, 
-            Observable<T1> o3, Observable<T2> o4, 
-            Observable<T1> o5, Observable<T2> o6, 
+            Observable<T3> o3, Observable<T4> o4,
+            Observable<T5> o5, Observable<T6> o6,
             Func7<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, R> combiner) {
         return create(new OperatorWithLatestFromMany<T, R>(this, 
                 new Observable<?>[] { o1, o2, o3, o4, o5, o6 }, null, Functions.fromFunc(combiner)));
@@ -12132,9 +12132,9 @@ public final <T1, T2, T3, T4, T5, T6, R> Observable<R> withLatestFrom(
     @Experimental
     public final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2, 
-            Observable<T1> o3, Observable<T2> o4, 
-            Observable<T1> o5, Observable<T2> o6, 
-            Observable<T1> o7,
+            Observable<T3> o3, Observable<T4> o4,
+            Observable<T5> o5, Observable<T6> o6,
+            Observable<T7> o7,
             Func8<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, R> combiner) {
         return create(new OperatorWithLatestFromMany<T, R>(this, 
                 new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7 }, null, Functions.fromFunc(combiner)));
@@ -12182,9 +12182,9 @@ public final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> withLatestFrom(
     @Experimental
     public final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2, 
-            Observable<T1> o3, Observable<T2> o4, 
-            Observable<T1> o5, Observable<T2> o6, 
-            Observable<T1> o7, Observable<T2> o8, 
+            Observable<T3> o3, Observable<T4> o4,
+            Observable<T5> o5, Observable<T6> o6,
+            Observable<T7> o7, Observable<T8> o8,
             Func9<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, R> combiner) {
         return create(new OperatorWithLatestFromMany<T, R>(this, 
                 new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7, o8 }, null, Functions.fromFunc(combiner)));

From 70bb06af350a7f6f611985f9b61e48ce200d6219 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Thu, 1 Sep 2016 16:54:14 +1000
Subject: [PATCH 161/263] enhance generics on Observable.onErrorResumeNext and
 onErrorReturn (#4452)

---
 src/main/java/rx/Observable.java                            | 4 ++--
 .../operators/OperatorOnErrorResumeNextViaFunction.java     | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index b4104c3e3a..5d8d110917 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -8035,7 +8035,7 @@ public final Observable<T> onBackpressureLatest() {
      * @return the original Observable, with appropriately modified behavior
      * @see <a href="http://reactivex.io/documentation/operators/catch.html">ReactiveX operators documentation: Catch</a>
      */
-    public final Observable<T> onErrorResumeNext(final Func1<Throwable, ? extends Observable<? extends T>> resumeFunction) {
+    public final Observable<T> onErrorResumeNext(final Func1<? super Throwable, ? extends Observable<? extends T>> resumeFunction) {
         return lift(new OperatorOnErrorResumeNextViaFunction<T>(resumeFunction));
     }
 
@@ -8111,7 +8111,7 @@ public final Observable<T> onErrorResumeNext(final Observable<? extends T> resum
      * @see <a href="http://reactivex.io/documentation/operators/catch.html">ReactiveX operators documentation: Catch</a>
      */
     @SuppressWarnings("cast")
-    public final Observable<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunction) {
+    public final Observable<T> onErrorReturn(Func1<? super Throwable, ? extends T> resumeFunction) {
         return lift((Operator<T, T>)OperatorOnErrorResumeNextViaFunction.withSingle(resumeFunction));
     }
 
diff --git a/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java b/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
index d78b75ce57..bbda214290 100644
--- a/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
+++ b/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
@@ -44,9 +44,9 @@
  */
 public final class OperatorOnErrorResumeNextViaFunction<T> implements Operator<T, T> {
 
-    final Func1<Throwable, ? extends Observable<? extends T>> resumeFunction;
+    final Func1<? super Throwable, ? extends Observable<? extends T>> resumeFunction;
 
-    public static <T> OperatorOnErrorResumeNextViaFunction<T> withSingle(final Func1<Throwable, ? extends T> resumeFunction) {
+    public static <T> OperatorOnErrorResumeNextViaFunction<T> withSingle(final Func1<? super Throwable, ? extends T> resumeFunction) {
         return new OperatorOnErrorResumeNextViaFunction<T>(new Func1<Throwable, Observable<? extends T>>() {
             @Override
             public Observable<? extends T> call(Throwable t) {
@@ -76,7 +76,7 @@ public Observable<? extends T> call(Throwable t) {
         });
     }
 
-    public OperatorOnErrorResumeNextViaFunction(Func1<Throwable, ? extends Observable<? extends T>> f) {
+    public OperatorOnErrorResumeNextViaFunction(Func1<? super Throwable, ? extends Observable<? extends T>> f) {
         this.resumeFunction = f;
     }
 

From 30da1aa1e38a5ead8965d1784ab8c6df8111d354 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Volkan=20Yaz=C4=B1c=C4=B1?= <volkan.yazici@gmail.com>
Date: Thu, 1 Sep 2016 15:35:38 +0200
Subject: [PATCH 162/263] Throw unchecked exception in
 TestSubscriber#awaitValueCount(). (#4453)

---
 src/main/java/rx/observers/TestSubscriber.java     | 10 +++++++---
 src/test/java/rx/observers/TestSubscriberTest.java |  4 ++--
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/main/java/rx/observers/TestSubscriber.java b/src/main/java/rx/observers/TestSubscriber.java
index 43399def27..1dcf336091 100644
--- a/src/main/java/rx/observers/TestSubscriber.java
+++ b/src/main/java/rx/observers/TestSubscriber.java
@@ -355,13 +355,17 @@ private void assertItem(T expected, int i) {
      * @param timeout the time to wait for the events
      * @param unit the time unit of waiting
      * @return true if the expected number of onNext events happened
-     * @throws InterruptedException if the sleep is interrupted
+     * @throws RuntimeException if the sleep is interrupted
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
-    public final boolean awaitValueCount(int expected, long timeout, TimeUnit unit) throws InterruptedException {
+    public final boolean awaitValueCount(int expected, long timeout, TimeUnit unit) {
         while (timeout != 0 && valueCount < expected) {
-            unit.sleep(1);
+            try {
+                unit.sleep(1);
+            } catch (InterruptedException e) {
+                throw new IllegalStateException("Interrupted", e);
+            }
             timeout--;
         }
         return valueCount >= expected;
diff --git a/src/test/java/rx/observers/TestSubscriberTest.java b/src/test/java/rx/observers/TestSubscriberTest.java
index b5830822f8..c7d3c033c9 100644
--- a/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/src/test/java/rx/observers/TestSubscriberTest.java
@@ -750,7 +750,7 @@ public void completionCount() {
     }
     
     @Test
-    public void awaitValueCount() throws Exception {
+    public void awaitValueCount() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
         
         Observable.range(1, 5).delay(100, TimeUnit.MILLISECONDS)
@@ -763,7 +763,7 @@ public void awaitValueCount() throws Exception {
     }
     
     @Test
-    public void awaitValueCountFails() throws Exception {
+    public void awaitValueCountFails() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
         
         Observable.range(1, 2).delay(100, TimeUnit.MILLISECONDS)

From d4d55f0092627f06fee6c56748f18ad6411b84c6 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Fri, 2 Sep 2016 08:47:05 +0200
Subject: [PATCH 163/263] 1.x: Completable add doOnEach (#4460)

* 1.x: Completable add doOnEach

* Fix Generics
---
 src/main/java/rx/Completable.java     | 26 ++++++++++++++++++-
 src/test/java/rx/CompletableTest.java | 37 ++++++++++++++++++++++++++-
 2 files changed, 61 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 3ee09fd9bd..b45d0cd17e 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -1442,7 +1442,31 @@ public void onSubscribe(Subscription d) {
     public final Completable doOnCompleted(Action0 onCompleted) {
         return doOnLifecycle(Actions.empty(), Actions.empty(), onCompleted, Actions.empty(), Actions.empty());
     }
-    
+
+    /**
+     * Returns a Completable which calls the given onNotification callback when this Completable emits an error or completes.
+     * @param onNotification the notification callback
+     * @return the new Completable instance
+     * @throws NullPointerException if onNotification is null
+     */
+    public final Completable doOnEach(final Action1<Notification<Object>> onNotification) {
+        if (onNotification == null) {
+            throw new IllegalArgumentException("onNotification is null");
+        }
+
+        return doOnLifecycle(Actions.empty(), new Action1<Throwable>() {
+            @Override
+            public void call(final Throwable throwable) {
+                onNotification.call(Notification.createOnError(throwable));
+            }
+        }, new Action0() {
+            @Override
+            public void call() {
+                onNotification.call(Notification.createOnCompleted());
+            }
+        }, Actions.empty(), Actions.empty());
+    }
+
     /**
      * Returns a Completable which calls the given onUnsubscribe callback if the child subscriber cancels
      * the subscription.
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 2edb0a0d10..81b4c9524d 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -4174,4 +4174,39 @@ public Object call(Completable completable) {
         assertSame(expectedResult, actualResult);
         assertSame(c, completableRef.get());
     }
-}
\ No newline at end of file
+
+    @Test(expected = IllegalArgumentException.class)
+    public void doOnEachNullAction() {
+        Completable.complete().doOnEach(null);
+    }
+
+    @Test
+    public void doOnEachCompleted() {
+        final AtomicInteger atomicInteger = new AtomicInteger(0);
+        Completable.complete().doOnEach(new Action1<Notification<Object>>() {
+            @Override
+            public void call(final Notification<Object> notification) {
+                if (notification.isOnCompleted()) {
+                    atomicInteger.incrementAndGet();
+                }
+            }
+        }).subscribe();
+
+        assertEquals(1, atomicInteger.get());
+    }
+
+    @Test
+    public void doOnEachError() {
+        final AtomicInteger atomicInteger = new AtomicInteger(0);
+        Completable.error(new RuntimeException("What?")).doOnEach(new Action1<Notification<Object>>() {
+            @Override
+            public void call(final Notification<Object> notification) {
+                if (notification.isOnError()) {
+                    atomicInteger.incrementAndGet();
+                }
+            }
+        }).subscribe();
+
+        assertEquals(1, atomicInteger.get());
+    }
+}

From 75932471eda6c7c972a40b0560a65c75ffd8cbc2 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Fri, 2 Sep 2016 09:00:03 +0200
Subject: [PATCH 164/263] 1.x: Remove some unused fields (#4463)

---
 .../rx/internal/operators/CompletableOnSubscribeConcat.java   | 4 +---
 .../operators/CompletableOnSubscribeConcatIterable.java       | 4 +---
 .../rx/internal/operators/CompletableOnSubscribeMerge.java    | 4 +---
 .../java/rx/internal/operators/OnSubscribeCombineLatest.java  | 2 --
 4 files changed, 3 insertions(+), 11 deletions(-)

diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
index ecf658b94a..a7580d417e 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
@@ -45,7 +45,6 @@ public void call(CompletableSubscriber s) {
     static final class CompletableConcatSubscriber
     extends Subscriber<Completable> {
         final CompletableSubscriber actual;
-        final int prefetch;
         final SerialSubscription sr;
         
         final SpscArrayQueue<Completable> queue;
@@ -60,7 +59,6 @@ static final class CompletableConcatSubscriber
         
         public CompletableConcatSubscriber(CompletableSubscriber actual, int prefetch) {
             this.actual = actual;
-            this.prefetch = prefetch;
             this.queue = new SpscArrayQueue<Completable>(prefetch);
             this.sr = new SerialSubscription();
             this.inner = new ConcatInnerSubscriber();
@@ -149,4 +147,4 @@ public void onCompleted() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
index feaa0a984e..9d42d6187f 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
@@ -61,8 +61,6 @@ static final class ConcatInnerSubscriber extends AtomicInteger implements Comple
         final CompletableSubscriber actual;
         final Iterator<? extends Completable> sources;
         
-        int index;
-        
         final SerialSubscription sd;
         
         public ConcatInnerSubscriber(CompletableSubscriber actual, Iterator<? extends Completable> sources) {
@@ -132,4 +130,4 @@ void next() {
             } while (decrementAndGet() != 0);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
index 0eecf3fa32..38554fa302 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
@@ -50,7 +50,6 @@ static final class CompletableMergeSubscriber
     extends Subscriber<Completable> {
         final CompletableSubscriber actual;
         final CompositeSubscription set;
-        final int maxConcurrency;
         final boolean delayErrors;
         
         volatile boolean done;
@@ -63,7 +62,6 @@ static final class CompletableMergeSubscriber
         
         public CompletableMergeSubscriber(CompletableSubscriber actual, int maxConcurrency, boolean delayErrors) {
             this.actual = actual;
-            this.maxConcurrency = maxConcurrency;
             this.delayErrors = delayErrors;
             this.set = new CompositeSubscription();
             this.wip = new AtomicInteger(1);
@@ -211,4 +209,4 @@ public static Throwable collectErrors(Queue<Throwable> q) {
         }
         return new CompositeException(list);
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
index e7cb3a1251..2d4f12f467 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
@@ -89,7 +89,6 @@ static final class LatestCoordinator<T, R> extends AtomicInteger implements Prod
         private static final long serialVersionUID = 8567835998786448817L;
         final Subscriber<? super R> actual;
         final FuncN<? extends R> combiner;
-        final int count;
         final CombinerSubscriber<T, R>[] subscribers;
         final int bufferSize;
         final Object[] latest;
@@ -116,7 +115,6 @@ public LatestCoordinator(Subscriber<? super R> actual,
                 int count, int bufferSize, boolean delayError) {
             this.actual = actual;
             this.combiner = combiner;
-            this.count = count;
             this.bufferSize = bufferSize;
             this.delayError = delayError;
             this.latest = new Object[count];

From 11343ae031feb01d3d08ba5cd0e5f275ed798e68 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Fri, 2 Sep 2016 16:01:52 +0200
Subject: [PATCH 165/263] 1.x: Deprecate Notification.createOnCompleted (#4466)

---
 src/main/java/rx/Notification.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main/java/rx/Notification.java b/src/main/java/rx/Notification.java
index 9d50d09bb0..248820855d 100644
--- a/src/main/java/rx/Notification.java
+++ b/src/main/java/rx/Notification.java
@@ -67,8 +67,10 @@ public static <T> Notification<T> createOnCompleted() {
      *
      * @param <T> the actual value type held by the Notification
      * @param type
+     * @deprecated this method does the same as {@link #createOnCompleted()} and does not use the passed in type hence it's useless.
      * @return an {@code OnCompleted} variety of {@code Notification}
      */
+    @Deprecated
     @SuppressWarnings("unchecked")
     public static <T> Notification<T> createOnCompleted(Class<T> type) {
         return (Notification<T>) ON_COMPLETED;

From c307e4f2b157b1597f9d86c6fbd1ae1f9c069475 Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Mon, 5 Sep 2016 14:18:01 +0200
Subject: [PATCH 166/263] 1.x: Single add doOnEach (#4461)

* 1.x: Single add doOnEach

* Add JavaDoc
---
 src/main/java/rx/Single.java                  | 73 +++++++++++------
 src/main/java/rx/exceptions/Exceptions.java   | 14 ++++
 .../internal/operators/SingleDoOnEvent.java   | 79 +++++++++++++++++++
 src/test/java/rx/SingleTest.java              | 50 ++++++++++++
 4 files changed, 192 insertions(+), 24 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/SingleDoOnEvent.java

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 05d1b00f96..47d6208543 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -2406,27 +2406,54 @@ public final <T2, R> Single<R> zipWith(Single<? extends T2> other, Func2<? super
      *            the action to invoke if the source {@link Single} calls {@code onError}
      * @return the source {@link Single} with the side-effecting behavior applied
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
     public final Single<T> doOnError(final Action1<Throwable> onError) {
-        Observer<T> observer = new Observer<T>() {
+        if (onError == null) {
+            throw new IllegalArgumentException("onError is null");
+        }
+
+        return Single.create(new SingleDoOnEvent<T>(this, Actions.empty(), new Action1<Throwable>() {
             @Override
-            public void onCompleted() {
-                // deliberately ignored
+            public void call(final Throwable throwable) {
+                onError.call(throwable);
             }
+        }));
+    }
 
+    /**
+     * Modifies the source {@link Single} so that it invokes an action when it calls {@code onSuccess} or {@code onError}.
+     * <p>
+     * <img width="640" height="310" src="https://raw.githubusercontent.com/wiki/ReactiveX/RxJava/images/rx-operators/doOnEach.png" alt="">
+     * <dl>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code doOnEach} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param onNotification
+     *            the action to invoke when the source {@link Single} calls {@code onSuccess} or {@code onError}.
+     * @return the source {@link Single} with the side-effecting behavior applied
+     * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public final Single<T> doOnEach(final Action1<Notification<? extends T>> onNotification) {
+        if (onNotification == null) {
+            throw new IllegalArgumentException("onNotification is null");
+        }
+
+        return Single.create(new SingleDoOnEvent<T>(this, new Action1<T>() {
             @Override
-            public void onError(Throwable e) {
-                onError.call(e);
+            public void call(final T t) {
+                onNotification.call(Notification.<T>createOnNext(t));
             }
-
+        }, new Action1<Throwable>() {
             @Override
-            public void onNext(T t) {
-                // deliberately ignored
+            public void call(final Throwable throwable) {
+                onNotification.call(Notification.<T>createOnError(throwable));
             }
-        };
-
-        return Observable.create(new OnSubscribeDoOnEach<T>(this.toObservable(), observer)).toSingle();
+        }));
     }
     
     /**
@@ -2442,27 +2469,25 @@ public void onNext(T t) {
      *            the action to invoke when the source {@link Single} calls {@code onSuccess}
      * @return the source {@link Single} with the side-effecting behavior applied
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
     public final Single<T> doOnSuccess(final Action1<? super T> onSuccess) {
-        Observer<T> observer = new Observer<T>() {
-            @Override
-            public void onCompleted() {
-                // deliberately ignored
-            }
+        if (onSuccess == null) {
+            throw new IllegalArgumentException("onSuccess is null");
+        }
 
+        return Single.create(new SingleDoOnEvent<T>(this, new Action1<T>() {
             @Override
-            public void onError(Throwable e) {
-                // deliberately ignored
+            public void call(final T t) {
+                onSuccess.call(t);
             }
-
+        }, new Action1<Throwable>() {
             @Override
-            public void onNext(T t) {
-                onSuccess.call(t);
+            public void call(final Throwable throwable) {
+                // Do nothing.
             }
-        };
-
-        return Observable.create(new OnSubscribeDoOnEach<T>(this.toObservable(), observer)).toSingle();
+        }));
     }
 
     /**
diff --git a/src/main/java/rx/exceptions/Exceptions.java b/src/main/java/rx/exceptions/Exceptions.java
index de36d5e134..d82015581a 100644
--- a/src/main/java/rx/exceptions/Exceptions.java
+++ b/src/main/java/rx/exceptions/Exceptions.java
@@ -190,6 +190,20 @@ public static void throwOrReport(Throwable t, Observer<?> o, Object value) {
         o.onError(OnErrorThrowable.addValueAsLastCause(t, value));
     }
 
+    /**
+     * Forwards a fatal exception or reports it along with the value
+     * caused it to the given SingleSubscriber.
+     * @param t the exception
+     * @param o the observer to report to
+     * @param value the value that caused the exception
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public static void throwOrReport(Throwable t, SingleSubscriber<?> o, Object value) {
+        Exceptions.throwIfFatal(t);
+        o.onError(OnErrorThrowable.addValueAsLastCause(t, value));
+    }
+
     /**
      * Forwards a fatal exception or reports it to the given Observer.
      * @param t the exception
diff --git a/src/main/java/rx/internal/operators/SingleDoOnEvent.java b/src/main/java/rx/internal/operators/SingleDoOnEvent.java
new file mode 100644
index 0000000000..102d3ee8cc
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleDoOnEvent.java
@@ -0,0 +1,79 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.Single;
+import rx.SingleSubscriber;
+import rx.exceptions.CompositeException;
+import rx.exceptions.Exceptions;
+import rx.functions.Action1;
+
+public final class SingleDoOnEvent<T> implements Single.OnSubscribe<T> {
+    final Single<T> source;
+    final Action1<? super T> onSuccess;
+    final Action1<Throwable> onError;
+
+    public SingleDoOnEvent(Single<T> source, Action1<? super T> onSuccess, Action1<Throwable> onError) {
+        this.source = source;
+        this.onSuccess = onSuccess;
+        this.onError = onError;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> actual) {
+        SingleDoOnEventSubscriber<T> parent = new SingleDoOnEventSubscriber<T>(actual, onSuccess, onError);
+        actual.add(parent);
+        source.subscribe(parent);
+    }
+
+    static final class SingleDoOnEventSubscriber<T> extends SingleSubscriber<T> {
+        final SingleSubscriber<? super T> actual;
+        final Action1<? super T> onSuccess;
+        final Action1<Throwable> onError;
+
+        SingleDoOnEventSubscriber(SingleSubscriber<? super T> actual, Action1<? super T> onSuccess, Action1<Throwable> onError) {
+            this.actual = actual;
+            this.onSuccess = onSuccess;
+            this.onError = onError;
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            try {
+                onSuccess.call(value);
+            } catch (Throwable e) {
+                Exceptions.throwOrReport(e, this, value);
+                return;
+            }
+
+            actual.onSuccess(value);
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            try {
+                onError.call(error);
+            } catch (Throwable e) {
+                Exceptions.throwIfFatal(e);
+                actual.onError(new CompositeException(error, e));
+                return;
+            }
+
+            actual.onError(error);
+        }
+    }
+}
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index fa68df8a16..d4bd0748b3 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -869,6 +869,11 @@ public void toCompletableError() {
         testSubscriber.assertNotCompleted();
     }
 
+    @Test(expected = IllegalArgumentException.class)
+    public void doOnErrorNull() {
+        Single.just(1).doOnError(null);
+    }
+
     @Test
     public void doOnErrorShouldNotCallActionIfNoErrorHasOccurred() {
         @SuppressWarnings("unchecked")
@@ -974,6 +979,11 @@ public void shouldPassErrorFromCallable() throws Exception {
         verify(callable).call();
     }
 
+    @Test(expected = IllegalArgumentException.class)
+    public void doOnSuccessNull() {
+        Single.just(1).doOnSuccess(null);
+    }
+
     @Test
     public void doOnSuccessShouldInvokeAction() {
         @SuppressWarnings("unchecked")
@@ -2086,4 +2096,44 @@ public Object call(Single<String> single) {
         assertSame(expectedResult, actualResult);
         assertSame(s, singleRef.get());
     }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void doOnEachNull() {
+        Single.just(1).doOnEach(null);
+    }
+
+    @Test
+    public void doOnEachError() {
+        final AtomicInteger atomicInteger = new AtomicInteger(0);
+        Single.error(new RuntimeException()).doOnEach(new Action1<Notification<?>>() {
+            @Override
+            public void call(final Notification<?> notification) {
+                if (notification.isOnError()) {
+                    atomicInteger.incrementAndGet();
+                }
+            }
+        }).subscribe(Actions.empty(), new Action1<Throwable>() {
+            @Override
+            public void call(final Throwable throwable) {
+                // Do nothing this is expected.
+            }
+        });
+
+        assertEquals(1, atomicInteger.get());
+    }
+
+    @Test
+    public void doOnEachSuccess() {
+        final AtomicInteger atomicInteger = new AtomicInteger(0);
+        Single.just(1).doOnEach(new Action1<Notification<? extends Integer>>() {
+            @Override
+            public void call(final Notification<? extends Integer> notification) {
+                if (notification.isOnNext()) {
+                    atomicInteger.getAndAdd(notification.getValue());
+                }
+            }
+        }).subscribe();
+
+        assertEquals(1, atomicInteger.get());
+    }
 }

From d86cf19e918152ea71d895aef5f1ee2d05f5a67f Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Mon, 5 Sep 2016 14:21:12 +0200
Subject: [PATCH 167/263] Update changes.md

---
 CHANGES.md                             | 33 ++++++++++++++++++++++++++
 src/test/java/rx/NotificationTest.java |  1 +
 2 files changed, 34 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 745a0f83cd..2a9bd70a0c 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,38 @@
 # RxJava Releases #
 
+### Version 1.1.10 - September 5, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.10%7C))
+
+The release contains a few javadoc and internal cleanups, some enhancements and some deprecations.
+
+**Notable renames:**
+
+  - `fromAsync` is now `fromEmitter`
+  - `rx.Completable.CompletableSubscriber` is now `rx.CompletableSubscriber`
+
+#### API enhancements
+
+  - [Pull 4423](https://github.com/ReactiveX/RxJava/pull/4423): add free-form conversion operator `to(Func1)` to `Observable`, `Single` and `Completable`.
+  - [Pull 4425](https://github.com/ReactiveX/RxJava/pull/4425): Rename `Completable` helper interfaces by dropping the `Completable` prefix, move `rx.Completable.CompletableSubscriber` to `rx.CompletableSubscriber`.
+  - [Pull 4442](https://github.com/ReactiveX/RxJava/pull/4442): Rename `fromAsync` to `fromEmitter`.  
+  - [Pull 4452](https://github.com/ReactiveX/RxJava/pull/4452): Enhance generics on Observable.onErrorResumeNext and onErrorReturn 
+  - [Pull 4442](https://github.com/ReactiveX/RxJava/pull/4442): Add `Completable.fromEmitter`
+  - [Pull 4453](https://github.com/ReactiveX/RxJava/pull/4453): Remove `throws InterruptedException` from `TestSubscriber.awaitValueCount()` 
+  - [Pull 4460](https://github.com/ReactiveX/RxJava/pull/4460): Add `Completable.doOnEach(Action1)`
+  - [Pull 4461](https://github.com/ReactiveX/RxJava/pull/4461): Add `Single.doOnEach`
+
+#### Deprecations
+
+  - [Pull 4425](https://github.com/ReactiveX/RxJava/pull/4425): Deprecate `CompletableOnSubscribe`, `CompletableOperator` and `CompletableTransformer` and rename them by dropping the `Completable` prefix
+  - [Pull 4442](https://github.com/ReactiveX/RxJava/pull/4442): Deprecate `Observable.fromAsync` by renaming it to `Observable.fromEmitter`.
+  - [Pull 4466](https://github.com/ReactiveX/RxJava/pull/4466): Deprecate `Notification.createOnCompleted(Class)`
+
+#### Bugfixes
+
+  - [Pull 4397](https://github.com/ReactiveX/RxJava/pull/4397): Fix multiple values produced by `throttleFirst` with `TestScheduler`
+  - [Pull 4427](https://github.com/ReactiveX/RxJava/pull/4427): Fix `Observable.fromEmitter` (formerly `Observable.fromAsync`) post-complete event suppression
+  - [Pull 4447](https://github.com/ReactiveX/RxJava/pull/4447): Fix type parameters of `Observable.withLatestFrom`
+
+
 ### Version 1.1.9 - August 12, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.9%7C))
 
 This release contains mostly internal cleanups, reinforced Observable-protocol adherence and minor javadoc fixes.
diff --git a/src/test/java/rx/NotificationTest.java b/src/test/java/rx/NotificationTest.java
index b7997dc50d..34aa36de8e 100644
--- a/src/test/java/rx/NotificationTest.java
+++ b/src/test/java/rx/NotificationTest.java
@@ -87,6 +87,7 @@ public void testOnErrorIntegerNotificationWhenNotEqual(){
 
     @Test
     public void createWithClass() {
+        @SuppressWarnings("deprecation")
         Notification<Integer> n = Notification.createOnCompleted(Integer.class);
         assertTrue(n.isOnCompleted());
         assertFalse(n.hasThrowable());

From ff16f76de6d7a6d47de250ff48f6fb7ab611067f Mon Sep 17 00:00:00 2001
From: Niklas Baudy <niklas.baudy@vanniktech.de>
Date: Thu, 8 Sep 2016 10:00:28 +0200
Subject: [PATCH 168/263] 1.x: Remove trailing whitespace (#4500)

---
 src/main/java/rx/AsyncEmitter.java            |   16 +-
 src/main/java/rx/Completable.java             |  430 ++---
 src/main/java/rx/CompletableEmitter.java      |    8 +-
 src/main/java/rx/Notification.java            |   22 +-
 src/main/java/rx/Observable.java              | 1244 ++++++-------
 src/main/java/rx/Observer.java                |   12 +-
 src/main/java/rx/Producer.java                |   20 +-
 src/main/java/rx/Scheduler.java               |    2 +-
 src/main/java/rx/Single.java                  |  144 +-
 src/main/java/rx/SingleSubscriber.java        |   18 +-
 src/main/java/rx/Subscriber.java              |   38 +-
 src/main/java/rx/Subscription.java            |    6 +-
 src/main/java/rx/annotations/Beta.java        |    8 +-
 .../java/rx/annotations/Experimental.java     |   10 +-
 .../AssemblyStackTraceException.java          |   20 +-
 .../rx/exceptions/CompositeException.java     |   26 +-
 src/main/java/rx/exceptions/Exceptions.java   |   20 +-
 .../MissingBackpressureException.java         |    6 +-
 .../OnCompletedFailedException.java           |    8 +-
 .../rx/exceptions/OnErrorFailedException.java |    6 +-
 .../OnErrorNotImplementedException.java       |    6 +-
 .../java/rx/exceptions/OnErrorThrowable.java  |   16 +-
 .../UnsubscribeFailedException.java           |   10 +-
 src/main/java/rx/exceptions/package-info.java |    2 +-
 src/main/java/rx/functions/Action.java        |    6 +-
 src/main/java/rx/functions/Action0.java       |    6 +-
 src/main/java/rx/functions/Action1.java       |    6 +-
 src/main/java/rx/functions/Action2.java       |    6 +-
 src/main/java/rx/functions/Action3.java       |    6 +-
 src/main/java/rx/functions/Action4.java       |    6 +-
 src/main/java/rx/functions/Action5.java       |    6 +-
 src/main/java/rx/functions/Action6.java       |    6 +-
 src/main/java/rx/functions/Action7.java       |    6 +-
 src/main/java/rx/functions/Action8.java       |    6 +-
 src/main/java/rx/functions/Action9.java       |    6 +-
 src/main/java/rx/functions/ActionN.java       |    6 +-
 src/main/java/rx/functions/Actions.java       |   60 +-
 src/main/java/rx/functions/Func0.java         |    6 +-
 src/main/java/rx/functions/Func1.java         |    6 +-
 src/main/java/rx/functions/Func2.java         |    6 +-
 src/main/java/rx/functions/Func3.java         |    6 +-
 src/main/java/rx/functions/Func4.java         |    6 +-
 src/main/java/rx/functions/Func5.java         |    6 +-
 src/main/java/rx/functions/Func6.java         |    6 +-
 src/main/java/rx/functions/Func7.java         |    6 +-
 src/main/java/rx/functions/Func8.java         |    6 +-
 src/main/java/rx/functions/Func9.java         |    6 +-
 src/main/java/rx/functions/FuncN.java         |    6 +-
 src/main/java/rx/functions/Function.java      |    6 +-
 src/main/java/rx/functions/Functions.java     |   34 +-
 .../internal/operators/BackpressureUtils.java |  102 +-
 .../operators/BlockingOperatorLatest.java     |    6 +-
 .../operators/BlockingOperatorMostRecent.java |    6 +-
 .../operators/BlockingOperatorNext.java       |    8 +-
 .../operators/BlockingOperatorToFuture.java   |    8 +-
 .../operators/BlockingOperatorToIterator.java |   10 +-
 .../operators/BufferUntilSubscriber.java      |   14 +-
 .../internal/operators/CachedObservable.java  |   64 +-
 .../operators/CompletableFromEmitter.java     |   18 +-
 .../CompletableOnSubscribeConcat.java         |   42 +-
 .../CompletableOnSubscribeConcatArray.java    |   32 +-
 .../CompletableOnSubscribeConcatIterable.java |   46 +-
 .../CompletableOnSubscribeMerge.java          |   48 +-
 .../CompletableOnSubscribeMergeArray.java     |   22 +-
 ...etableOnSubscribeMergeDelayErrorArray.java |   28 +-
 ...bleOnSubscribeMergeDelayErrorIterable.java |   42 +-
 .../CompletableOnSubscribeMergeIterable.java  |   40 +-
 .../CompletableOnSubscribeTimeout.java        |   28 +-
 .../operators/DeferredScalarSubscriber.java   |   34 +-
 .../DeferredScalarSubscriberSafe.java         |    6 +-
 .../operators/EmptyObservableHolder.java      |   10 +-
 .../operators/NeverObservableHolder.java      |    8 +-
 .../internal/operators/NotificationLite.java  |   28 +-
 .../rx/internal/operators/OnSubscribeAmb.java |   26 +-
 .../operators/OnSubscribeAutoConnect.java     |   10 +-
 .../operators/OnSubscribeCollect.java         |   14 +-
 .../operators/OnSubscribeCombineLatest.java   |  102 +-
 .../operators/OnSubscribeConcatMap.java       |  110 +-
 .../internal/operators/OnSubscribeDefer.java  |    8 +-
 .../OnSubscribeDelaySubscription.java         |    4 +-
 .../OnSubscribeDelaySubscriptionOther.java    |   22 +-
 ...ubscribeDelaySubscriptionWithSelector.java |    2 +-
 .../internal/operators/OnSubscribeDetach.java |   54 +-
 .../operators/OnSubscribeDoOnEach.java        |   14 +-
 .../internal/operators/OnSubscribeFilter.java |   28 +-
 .../operators/OnSubscribeFlattenIterable.java |  132 +-
 .../operators/OnSubscribeFromArray.java       |   44 +-
 .../operators/OnSubscribeFromEmitter.java     |  148 +-
 .../operators/OnSubscribeFromIterable.java    |   38 +-
 .../operators/OnSubscribeGroupJoin.java       |   38 +-
 .../internal/operators/OnSubscribeJoin.java   |   26 +-
 .../internal/operators/OnSubscribeLift.java   |   10 +-
 .../rx/internal/operators/OnSubscribeMap.java |   36 +-
 .../operators/OnSubscribeOnAssembly.java      |   24 +-
 .../OnSubscribeOnAssemblyCompletable.java     |   20 +-
 .../OnSubscribeOnAssemblySingle.java          |   20 +-
 .../OnSubscribePublishMulticast.java          |  124 +-
 .../internal/operators/OnSubscribeRange.java  |   26 +-
 .../internal/operators/OnSubscribeRedo.java   |   42 +-
 .../internal/operators/OnSubscribeReduce.java |   20 +-
 .../operators/OnSubscribeReduceSeed.java      |   10 +-
 .../operators/OnSubscribeRefCount.java        |   10 +-
 .../operators/OnSubscribeSkipTimed.java       |    6 +-
 .../operators/OnSubscribeTakeLastOne.java     |    6 +-
 .../internal/operators/OnSubscribeThrow.java  |   10 +-
 .../operators/OnSubscribeTimerOnce.java       |    2 +-
 .../OnSubscribeTimerPeriodically.java         |    2 +-
 .../internal/operators/OnSubscribeToMap.java  |   18 +-
 .../operators/OnSubscribeToMultimap.java      |   32 +-
 .../OnSubscribeToObservableFuture.java        |    6 +-
 .../internal/operators/OnSubscribeUsing.java  |   10 +-
 .../rx/internal/operators/OperatorAll.java    |   10 +-
 .../rx/internal/operators/OperatorAny.java    |   10 +-
 .../operators/OperatorAsObservable.java       |   14 +-
 .../OperatorBufferWithSingleObservable.java   |   12 +-
 .../operators/OperatorBufferWithSize.java     |   82 +-
 .../OperatorBufferWithStartEndObservable.java |   18 +-
 .../operators/OperatorBufferWithTime.java     |    6 +-
 .../rx/internal/operators/OperatorCast.java   |   30 +-
 .../OperatorDebounceWithSelector.java         |   26 +-
 .../operators/OperatorDebounceWithTime.java   |   26 +-
 .../rx/internal/operators/OperatorDelay.java  |    8 +-
 .../operators/OperatorDelayWithSelector.java  |    2 +-
 .../operators/OperatorDematerialize.java      |   16 +-
 .../internal/operators/OperatorDistinct.java  |   14 +-
 .../OperatorDistinctUntilChanged.java         |   26 +-
 .../operators/OperatorDoAfterTerminate.java   |    6 +-
 .../operators/OperatorDoOnRequest.java        |    4 +-
 .../operators/OperatorEagerConcatMap.java     |   94 +-
 .../internal/operators/OperatorElementAt.java |   14 +-
 .../internal/operators/OperatorGroupBy.java   |  166 +-
 .../operators/OperatorIgnoreElements.java     |    8 +-
 .../operators/OperatorMapNotification.java    |   40 +-
 .../internal/operators/OperatorMapPair.java   |   34 +-
 .../operators/OperatorMaterialize.java        |   10 +-
 .../rx/internal/operators/OperatorMerge.java  |  100 +-
 .../internal/operators/OperatorMulticast.java |    8 +-
 .../internal/operators/OperatorObserveOn.java |   50 +-
 .../OperatorOnBackpressureBuffer.java         |    8 +-
 .../operators/OperatorOnBackpressureDrop.java |   10 +-
 .../OperatorOnBackpressureLatest.java         |   10 +-
 .../OperatorOnErrorResumeNextViaFunction.java |   24 +-
 .../internal/operators/OperatorPublish.java   |  146 +-
 .../rx/internal/operators/OperatorReplay.java |  216 +--
 .../operators/OperatorRetryWithPredicate.java |   18 +-
 .../OperatorSampleWithObservable.java         |   22 +-
 .../operators/OperatorSampleWithTime.java     |    8 +-
 .../rx/internal/operators/OperatorScan.java   |   58 +-
 .../operators/OperatorSequenceEqual.java      |    6 +-
 .../internal/operators/OperatorSerialize.java |   12 +-
 .../rx/internal/operators/OperatorSingle.java |   18 +-
 .../rx/internal/operators/OperatorSkip.java   |    6 +-
 .../internal/operators/OperatorSkipUntil.java |    8 +-
 .../internal/operators/OperatorSkipWhile.java |   10 +-
 .../operators/OperatorSubscribeOn.java        |   20 +-
 .../rx/internal/operators/OperatorSwitch.java |   78 +-
 .../operators/OperatorSwitchIfEmpty.java      |    8 +-
 .../rx/internal/operators/OperatorTake.java   |   16 +-
 .../internal/operators/OperatorTakeLast.java  |   26 +-
 .../operators/OperatorTakeLastTimed.java      |   34 +-
 .../internal/operators/OperatorTakeTimed.java |    8 +-
 .../internal/operators/OperatorTakeUntil.java |   16 +-
 .../operators/OperatorTakeUntilPredicate.java |   10 +-
 .../internal/operators/OperatorTakeWhile.java |    6 +-
 .../operators/OperatorThrottleFirst.java      |   10 +-
 .../operators/OperatorTimeInterval.java       |    6 +-
 .../internal/operators/OperatorTimeout.java   |    6 +-
 .../operators/OperatorTimeoutBase.java        |   32 +-
 .../OperatorTimeoutWithSelector.java          |    6 +-
 .../internal/operators/OperatorTimestamp.java |    6 +-
 .../operators/OperatorToObservableList.java   |   18 +-
 .../OperatorToObservableSortedList.java       |   10 +-
 .../operators/OperatorUnsubscribeOn.java      |   10 +-
 .../OperatorWindowWithObservable.java         |   32 +-
 .../OperatorWindowWithObservableFactory.java  |   38 +-
 .../operators/OperatorWindowWithSize.java     |  190 +-
 .../OperatorWindowWithStartEndObservable.java |   36 +-
 .../operators/OperatorWindowWithTime.java     |   42 +-
 .../operators/OperatorWithLatestFrom.java     |   14 +-
 .../operators/OperatorWithLatestFromMany.java |   84 +-
 .../rx/internal/operators/OperatorZip.java    |   24 +-
 .../operators/OperatorZipIterable.java        |    6 +-
 .../operators/SingleDoAfterTerminate.java     |   24 +-
 .../operators/SingleOnSubscribeMap.java       |   30 +-
 .../operators/SingleOnSubscribeUsing.java     |   30 +-
 .../internal/operators/SingleOperatorZip.java |    2 +-
 .../internal/producers/ProducerArbiter.java   |   28 +-
 .../producers/ProducerObserverArbiter.java    |   34 +-
 .../rx/internal/producers/QueuedProducer.java |   40 +-
 .../producers/QueuedValueProducer.java        |   24 +-
 .../producers/SingleDelayedProducer.java      |   14 +-
 .../schedulers/CachedThreadScheduler.java     |   12 +-
 .../schedulers/EventLoopsScheduler.java       |   24 +-
 .../schedulers/ExecutorScheduler.java         |   28 +-
 .../GenericScheduledExecutorService.java      |   20 +-
 ...enericScheduledExecutorServiceFactory.java |    8 +-
 .../internal/schedulers/NewThreadWorker.java  |   30 +-
 .../internal/schedulers/ScheduledAction.java  |    4 +-
 .../schedulers/SchedulerLifecycle.java        |   14 +-
 .../rx/internal/schedulers/SchedulerWhen.java |   14 +-
 .../internal/schedulers/SleepingAction.java   |    6 +-
 .../subscriptions/SequentialSubscription.java |   38 +-
 .../internal/subscriptions/Unsubscribed.java  |   10 +-
 .../util/ActionNotificationObserver.java      |    8 +-
 .../java/rx/internal/util/ActionObserver.java |    6 +-
 .../rx/internal/util/ActionSubscriber.java    |    6 +-
 .../util/BackpressureDrainManager.java        |   12 +-
 .../rx/internal/util/ExceptionsUtils.java     |   22 +-
 .../rx/internal/util/IndexedRingBuffer.java   |   90 +-
 .../util/InternalObservableUtils.java         |   58 +-
 .../rx/internal/util/LinkedArrayList.java     |   22 +-
 .../java/rx/internal/util/ObjectPool.java     |   18 +-
 .../rx/internal/util/ObserverSubscriber.java  |   12 +-
 .../java/rx/internal/util/OpenHashSet.java    |   50 +-
 .../rx/internal/util/PlatformDependent.java   |    4 +-
 .../java/rx/internal/util/RxRingBuffer.java   |   98 +-
 .../util/ScalarSynchronousObservable.java     |   30 +-
 .../rx/internal/util/SubscriptionList.java    |    8 +-
 .../rx/internal/util/SynchronizedQueue.java   |   40 +-
 .../rx/internal/util/UtilityFunctions.java    |   10 +-
 .../atomic/AtomicReferenceArrayQueue.java     |    4 +-
 .../util/atomic/BaseLinkedAtomicQueue.java    |    8 +-
 .../internal/util/atomic/LinkedQueueNode.java |    8 +-
 .../util/atomic/MpscLinkedAtomicQueue.java    |   16 +-
 .../util/atomic/SpscAtomicArrayQueue.java     |    6 +-
 .../atomic/SpscExactAtomicArrayQueue.java     |   18 +-
 .../util/atomic/SpscLinkedArrayQueue.java     |   24 +-
 .../util/atomic/SpscLinkedAtomicQueue.java    |   14 +-
 .../atomic/SpscUnboundedAtomicArrayQueue.java |    8 +-
 .../internal/util/unsafe/BaseLinkedQueue.java |   22 +-
 .../unsafe/ConcurrentCircularArrayQueue.java  |   26 +-
 ...ConcurrentSequencedCircularArrayQueue.java |    2 +-
 .../util/unsafe/MessagePassingQueue.java      |   24 +-
 .../internal/util/unsafe/MpmcArrayQueue.java  |    4 +-
 .../internal/util/unsafe/MpscLinkedQueue.java |   22 +-
 .../java/rx/internal/util/unsafe/Pow2.java    |    2 +-
 .../util/unsafe/QueueProgressIndicators.java  |   12 +-
 .../internal/util/unsafe/SpmcArrayQueue.java  |   14 +-
 .../internal/util/unsafe/SpscArrayQueue.java  |   18 +-
 .../internal/util/unsafe/SpscLinkedQueue.java |   14 +-
 .../util/unsafe/SpscUnboundedArrayQueue.java  |   10 +-
 .../rx/internal/util/unsafe/UnsafeAccess.java |   12 +-
 .../java/rx/observables/AsyncOnSubscribe.java |  102 +-
 .../rx/observables/BlockingObservable.java    |   48 +-
 .../rx/observables/ConnectableObservable.java |   24 +-
 .../rx/observables/GroupedObservable.java     |   14 +-
 .../java/rx/observables/SyncOnSubscribe.java  |   72 +-
 .../observers/AsyncCompletableSubscriber.java |   32 +-
 src/main/java/rx/observers/Observers.java     |   12 +-
 .../observers/SafeCompletableSubscriber.java  |   20 +-
 .../java/rx/observers/SafeSubscriber.java     |   30 +-
 .../java/rx/observers/SerializedObserver.java |   16 +-
 .../rx/observers/SerializedSubscriber.java    |   12 +-
 src/main/java/rx/observers/Subscribers.java   |   20 +-
 src/main/java/rx/observers/TestObserver.java  |   22 +-
 .../java/rx/observers/TestSubscriber.java     |   78 +-
 src/main/java/rx/package-info.java            |   12 +-
 .../RxJavaCompletableExecutionHook.java       |    2 +-
 .../java/rx/plugins/RxJavaErrorHandler.java   |   10 +-
 src/main/java/rx/plugins/RxJavaHooks.java     |  144 +-
 .../RxJavaObservableExecutionHook.java        |   20 +-
 .../RxJavaObservableExecutionHookDefault.java |   10 +-
 src/main/java/rx/plugins/RxJavaPlugins.java   |   48 +-
 .../rx/plugins/RxJavaSingleExecutionHook.java |    2 +-
 .../RxJavaSingleExecutionHookDefault.java     |    8 +-
 .../rx/schedulers/ImmediateScheduler.java     |    8 +-
 .../rx/schedulers/NewThreadScheduler.java     |    8 +-
 src/main/java/rx/schedulers/Schedulers.java   |   28 +-
 .../java/rx/schedulers/TestScheduler.java     |   10 +-
 src/main/java/rx/schedulers/TimeInterval.java |    8 +-
 src/main/java/rx/schedulers/Timestamped.java  |   10 +-
 .../rx/schedulers/TrampolineScheduler.java    |    2 +-
 src/main/java/rx/schedulers/package-info.java |    8 +-
 src/main/java/rx/singles/BlockingSingle.java  |    2 +-
 src/main/java/rx/subjects/AsyncSubject.java   |   10 +-
 .../java/rx/subjects/BehaviorSubject.java     |   24 +-
 src/main/java/rx/subjects/PublishSubject.java |   74 +-
 src/main/java/rx/subjects/ReplaySubject.java  |  294 +--
 .../java/rx/subjects/SerializedSubject.java   |    8 +-
 src/main/java/rx/subjects/Subject.java        |   14 +-
 .../subjects/SubjectSubscriptionManager.java  |    8 +-
 src/main/java/rx/subjects/TestSubject.java    |    8 +-
 src/main/java/rx/subjects/UnicastSubject.java |   42 +-
 .../rx/subscriptions/BooleanSubscription.java |    6 +-
 .../MultipleAssignmentSubscription.java       |    8 +-
 .../subscriptions/RefCountSubscription.java   |   10 +-
 .../rx/subscriptions/SerialSubscription.java  |   10 +-
 .../java/rx/subscriptions/Subscriptions.java  |   12 +-
 src/perf/java/rx/DeferredScalarPerf.java      |   22 +-
 src/perf/java/rx/ObservablePerfBaseline.java  |    8 +-
 src/perf/java/rx/OneItemPerf.java             |   28 +-
 src/perf/java/rx/ScalarJustPerf.java          |   50 +-
 src/perf/java/rx/SinglePerfBaseline.java      |   14 +-
 src/perf/java/rx/SingleSourcePerf.java        |   92 +-
 src/perf/java/rx/SubscribingPerf.java         |   48 +-
 src/perf/java/rx/internal/AtomicPerf.java     |   14 +-
 .../rx/internal/IndexedRingBufferPerf.java    |    6 +-
 .../rx/jmh/InputWithIncrementingInteger.java  |    8 +-
 .../rx/jmh/PerfAsyncSingleSubscriber.java     |   12 +-
 .../java/rx/jmh/PerfSingleSubscriber.java     |    6 +-
 src/perf/java/rx/observables/MultiInput.java  |    6 +-
 src/perf/java/rx/observables/SingleInput.java |    6 +-
 .../rx/observables/SyncOnSubscribePerf.java   |    8 +-
 .../rx/operators/ConcatMapInterablePerf.java  |   28 +-
 src/perf/java/rx/operators/ConcatPerf.java    |   20 +-
 .../rx/operators/FlatMapAsFilterPerf.java     |   30 +-
 src/perf/java/rx/operators/FlatMapPerf.java   |    4 +-
 .../java/rx/operators/FlatMapRangePerf.java   |   14 +-
 .../java/rx/operators/FromComparison.java     |   32 +-
 .../java/rx/operators/FromIterablePerf.java   |   16 +-
 .../rx/operators/OperatorObserveOnPerf.java   |    4 +-
 .../rx/operators/OperatorPublishPerf.java     |   22 +-
 .../java/rx/operators/OperatorRangePerf.java  |    8 +-
 .../rx/operators/OperatorTakeLastOnePerf.java |    6 +-
 src/perf/java/rx/operators/RedoPerf.java      |   48 +-
 src/perf/java/rx/operators/ZipPerf.java       |   36 +-
 .../java/rx/subjects/PublishSubjectPerf.java  |   20 +-
 .../java/rx/subjects/ReplaySubjectPerf.java   |    6 +-
 .../CompositeSubscriptionConcurrentPerf.java  |   28 +-
 .../CompositeSubscriptionPerf.java            |   22 +-
 .../MultipleAssignmentSubscriptionPerf.java   |   16 +-
 .../subscriptions/SerialSubscriptionPerf.java |   16 +-
 .../SubscriptionListConcurrentPerf.java       |   20 +-
 .../subscriptions/SubscriptionListPerf.java   |   16 +-
 src/test/java/rx/BackpressureTests.java       |   20 +-
 src/test/java/rx/CombineLatestTests.java      |    6 +-
 src/test/java/rx/CompletableTest.java         | 1588 ++++++++---------
 src/test/java/rx/ConcatTests.java             |   18 +-
 src/test/java/rx/CovarianceTest.java          |   14 +-
 src/test/java/rx/ErrorHandlingTests.java      |    6 +-
 src/test/java/rx/EventStream.java             |    6 +-
 src/test/java/rx/GroupByTests.java            |   12 +-
 src/test/java/rx/IntervalDemo.java            |    6 +-
 src/test/java/rx/MergeTests.java              |    8 +-
 src/test/java/rx/NotificationTest.java        |   22 +-
 .../java/rx/ObservableConversionTest.java     |   36 +-
 src/test/java/rx/ObservableDoOnTest.java      |    6 +-
 src/test/java/rx/ObservableTests.java         |  126 +-
 src/test/java/rx/ObservableWindowTests.java   |    6 +-
 src/test/java/rx/ReduceTests.java             |   10 +-
 src/test/java/rx/ScanTests.java               |    6 +-
 src/test/java/rx/SchedulerWorkerTest.java     |   62 +-
 src/test/java/rx/SingleTest.java              |   28 +-
 src/test/java/rx/StartWithTests.java          |    6 +-
 src/test/java/rx/SubscriberTest.java          |   28 +-
 src/test/java/rx/TestUtil.java                |   28 +-
 src/test/java/rx/ThrottleLastTests.java       |    6 +-
 .../java/rx/ThrottleWithTimeoutTests.java     |   12 +-
 src/test/java/rx/ZipTests.java                |    8 +-
 .../rx/exceptions/CompositeExceptionTest.java |   34 +-
 .../rx/exceptions/ExceptionsNullTest.java     |   36 +-
 .../java/rx/exceptions/ExceptionsTest.java    |   12 +-
 .../java/rx/exceptions/OnNextValueTest.java   |   24 +-
 .../java/rx/exceptions/TestException.java     |    6 +-
 src/test/java/rx/functions/ActionsTest.java   |   66 +-
 src/test/java/rx/functions/FunctionsTest.java |  102 +-
 .../operators/BackpressureUtilsTest.java      |    2 +-
 .../operators/BlockingOperatorLatestTest.java |    6 +-
 .../BlockingOperatorMostRecentTest.java       |    6 +-
 .../operators/BlockingOperatorNextTest.java   |   28 +-
 .../BlockingOperatorToFutureTest.java         |    6 +-
 .../BlockingOperatorToIteratorTest.java       |    6 +-
 .../operators/CachedObservableTest.java       |   82 +-
 .../operators/CompletableFromEmitterTest.java |   86 +-
 .../DeferredScalarSubscriberTest.java         |  134 +-
 .../operators/NotificationLiteTest.java       |   16 +-
 .../operators/OnSubscribeAmbTest.java         |  104 +-
 .../operators/OnSubscribeCollectTest.java     |   20 +-
 .../OnSubscribeCombineLatestTest.java         |   70 +-
 .../OnSubscribeConcatDelayErrorTest.java      |   68 +-
 .../operators/OnSubscribeDeferTest.java       |   18 +-
 ...OnSubscribeDelaySubscriptionOtherTest.java |  136 +-
 .../operators/OnSubscribeDetachTest.java      |   84 +-
 .../operators/OnSubscribeDoOnEachTest.java    |   30 +-
 .../operators/OnSubscribeFilterTest.java      |   40 +-
 .../OnSubscribeFlattenIterableTest.java       |  166 +-
 .../operators/OnSubscribeFromArrayTest.java   |   24 +-
 .../operators/OnSubscribeFromEmitterTest.java |  276 +--
 .../OnSubscribeFromIterableTest.java          |   92 +-
 .../operators/OnSubscribeGroupJoinTest.java   |    6 +-
 .../operators/OnSubscribeJoinTest.java        |    6 +-
 .../operators/OnSubscribeMapTest.java         |   26 +-
 .../operators/OnSubscribeRangeTest.java       |   42 +-
 .../operators/OnSubscribeReduceTest.java      |   16 +-
 .../operators/OnSubscribeRefCountTest.java    |   20 +-
 .../operators/OnSubscribeSingleTest.java      |    2 +-
 .../operators/OnSubscribeTimerTest.java       |   24 +-
 .../operators/OnSubscribeToMapTest.java       |   30 +-
 .../operators/OnSubscribeToMultimapTest.java  |   44 +-
 .../OnSubscribeToObservableFutureTest.java    |   52 +-
 .../operators/OnSubscribeUsingTest.java       |   58 +-
 .../internal/operators/OperatorAllTest.java   |   20 +-
 .../internal/operators/OperatorAnyTest.java   |   20 +-
 .../operators/OperatorAsObservableTest.java   |   30 +-
 .../operators/OperatorBufferTest.java         |  280 +--
 .../internal/operators/OperatorCastTest.java  |   22 +-
 .../operators/OperatorConcatTest.java         |  130 +-
 .../operators/OperatorDebounceTest.java       |   20 +-
 .../operators/OperatorDefaultIfEmptyTest.java |   18 +-
 .../internal/operators/OperatorDelayTest.java |   34 +-
 .../operators/OperatorDematerializeTest.java  |   24 +-
 .../operators/OperatorDistinctTest.java       |    6 +-
 .../OperatorDistinctUntilChangedTest.java     |   24 +-
 .../OperatorDoAfterTerminateTest.java         |   12 +-
 .../operators/OperatorDoOnRequestTest.java    |   20 +-
 .../operators/OperatorDoOnSubscribeTest.java  |    6 +-
 .../OperatorDoOnUnsubscribeTest.java          |    8 +-
 .../operators/OperatorEagerConcatMapTest.java |  150 +-
 .../operators/OperatorElementAtTest.java      |    6 +-
 .../internal/operators/OperatorFirstTest.java |    6 +-
 .../operators/OperatorFlatMapTest.java        |   76 +-
 .../operators/OperatorGroupByTest.java        |   78 +-
 .../operators/OperatorIgnoreElementsTest.java |    8 +-
 .../internal/operators/OperatorLastTest.java  |    6 +-
 .../OperatorMapNotificationTest.java          |   32 +-
 .../operators/OperatorMapPairTest.java        |   20 +-
 .../operators/OperatorMaterializeTest.java    |   10 +-
 .../OperatorMergeDelayErrorTest.java          |   90 +-
 .../OperatorMergeMaxConcurrentTest.java       |   54 +-
 .../internal/operators/OperatorMergeTest.java |  126 +-
 .../operators/OperatorMulticastTest.java      |   14 +-
 .../operators/OperatorObserveOnTest.java      |  104 +-
 .../OperatorOnBackpressureBufferTest.java     |   16 +-
 .../OperatorOnBackpressureDropTest.java       |   36 +-
 .../OperatorOnBackpressureLatestTest.java     |   28 +-
 ...ratorOnErrorResumeNextViaFunctionTest.java |   22 +-
 ...torOnErrorResumeNextViaObservableTest.java |   28 +-
 .../operators/OperatorOnErrorReturnTest.java  |   26 +-
 ...nExceptionResumeNextViaObservableTest.java |   22 +-
 .../OperatorPublishFunctionTest.java          |   94 +-
 .../operators/OperatorPublishTest.java        |   66 +-
 .../operators/OperatorRepeatTest.java         |   60 +-
 .../operators/OperatorReplayTest.java         |  390 ++--
 .../internal/operators/OperatorRetryTest.java |   42 +-
 .../OperatorRetryWithPredicateTest.java       |   42 +-
 .../operators/OperatorSampleTest.java         |   90 +-
 .../internal/operators/OperatorScanTest.java  |   54 +-
 .../operators/OperatorSequenceEqualTest.java  |    6 +-
 .../operators/OperatorSerializeTest.java      |   20 +-
 .../operators/OperatorSingleTest.java         |   24 +-
 .../operators/OperatorSkipLastTest.java       |   22 +-
 .../operators/OperatorSkipLastTimedTest.java  |    6 +-
 .../internal/operators/OperatorSkipTest.java  |   24 +-
 .../operators/OperatorSkipTimedTest.java      |    8 +-
 .../operators/OperatorSkipUntilTest.java      |    6 +-
 .../operators/OperatorSkipWhileTest.java      |   24 +-
 .../operators/OperatorSubscribeOnTest.java    |    6 +-
 .../operators/OperatorSwitchIfEmptyTest.java  |    6 +-
 .../operators/OperatorSwitchTest.java         |  112 +-
 .../operators/OperatorTakeLastOneTest.java    |    4 +-
 .../operators/OperatorTakeLastTest.java       |   68 +-
 .../operators/OperatorTakeLastTimedTest.java  |   50 +-
 .../internal/operators/OperatorTakeTest.java  |   44 +-
 .../operators/OperatorTakeTimedTest.java      |   24 +-
 .../OperatorTakeUntilPredicateTest.java       |   36 +-
 .../operators/OperatorTakeUntilTest.java      |   42 +-
 .../operators/OperatorTakeWhileTest.java      |   28 +-
 .../operators/OperatorThrottleFirstTest.java  |   14 +-
 .../operators/OperatorTimeIntervalTest.java   |   16 +-
 .../operators/OperatorTimeoutTests.java       |   46 +-
 .../OperatorTimeoutWithSelectorTest.java      |   12 +-
 .../operators/OperatorTimestampTest.java      |   18 +-
 .../OperatorToObservableListTest.java         |   16 +-
 .../OperatorToObservableSortedListTest.java   |   20 +-
 .../operators/OperatorUnsubscribeOnTest.java  |   10 +-
 .../OperatorWindowWithObservableTest.java     |   54 +-
 .../operators/OperatorWindowWithSizeTest.java |   66 +-
 ...ratorWindowWithStartEndObservableTest.java |   40 +-
 .../operators/OperatorWindowWithTimeTest.java |   34 +-
 .../operators/OperatorWithLatestFromTest.java |  306 ++--
 .../operators/OperatorZipCompletionTest.java  |    8 +-
 .../operators/OperatorZipIterableTest.java    |   14 +-
 .../internal/operators/OperatorZipTest.java   |   72 +-
 .../operators/SafeSubscriberTest.java         |    6 +-
 .../operators/SingleDoAfterTerminateTest.java |   20 +-
 .../operators/SingleOnSubscribeUsingTest.java |   26 +-
 .../ProducerObserverArbiterTest.java          |    6 +-
 .../rx/internal/producers/ProducersTest.java  |  154 +-
 .../producers/SingleDelayedProducerTest.java  |    8 +-
 .../producers/SingleProducerTest.java         |   12 +-
 .../schedulers/ExecutorSchedulerTest.java     |   66 +-
 .../GenericScheduledExecutorServiceTest.java  |    8 +-
 .../rx/internal/util/BlockingUtilsTest.java   |    4 +-
 .../rx/internal/util/ExceptionUtilsTest.java  |    6 +-
 .../internal/util/IndexedRingBufferTest.java  |    6 +-
 .../rx/internal/util/JCToolsQueueTests.java   |  150 +-
 .../rx/internal/util/LinkedArrayListTest.java |   10 +-
 .../rx/internal/util/OpenHashSetTest.java     |   12 +-
 .../rx/internal/util/RxRingBufferBase.java    |    6 +-
 .../internal/util/RxRingBufferSpmcTest.java   |    8 +-
 .../internal/util/RxRingBufferSpscTest.java   |    6 +-
 .../util/RxRingBufferWithoutUnsafeTest.java   |    8 +-
 .../util/ScalarSynchronousObservableTest.java |   26 +-
 .../internal/util/SubscriptionListTest.java   |   32 +-
 .../internal/util/SynchronizedQueueTest.java  |   48 +-
 .../internal/util/UtilityFunctionsTest.java   |    2 +-
 .../rx/observables/AsyncOnSubscribeTest.java  |   66 +-
 .../observables/BlockingObservableTest.java   |   34 +-
 .../ConnectableObservableTest.java            |   66 +-
 .../rx/observables/SyncOnSubscribeTest.java   |  136 +-
 .../AsyncCompletableSubscriberTest.java       |   38 +-
 .../observers/CompletableSubscriberTest.java  |   94 +-
 src/test/java/rx/observers/ObserversTest.java |   78 +-
 .../java/rx/observers/SafeObserverTest.java   |   16 +-
 .../java/rx/observers/SafeSubscriberTest.java |   64 +-
 .../rx/observers/SerializedObserverTest.java  |  106 +-
 .../java/rx/observers/SubscribersTest.java    |   48 +-
 .../java/rx/observers/TestObserverTest.java   |   46 +-
 .../java/rx/observers/TestSubscriberTest.java |  166 +-
 src/test/java/rx/plugins/RxJavaHooksTest.java |  358 ++--
 .../java/rx/plugins/RxJavaPluginsTest.java    |   22 +-
 .../AbstractSchedulerConcurrencyTests.java    |   86 +-
 .../rx/schedulers/AbstractSchedulerTests.java |   96 +-
 .../schedulers/ComputationSchedulerTests.java |   20 +-
 .../schedulers/DeprecatedSchedulersTest.java  |   12 +-
 .../GenericScheduledExecutorServiceTest.java  |   14 +-
 .../rx/schedulers/ImmediateSchedulerTest.java |    6 +-
 .../java/rx/schedulers/IoSchedulerTest.java   |    2 +-
 .../rx/schedulers/NewThreadSchedulerTest.java |   16 +-
 .../rx/schedulers/ResetSchedulersTest.java    |    6 +-
 .../rx/schedulers/SchedulerLifecycleTest.java |   36 +-
 .../java/rx/schedulers/SchedulerTests.java    |    2 +-
 .../java/rx/schedulers/SchedulerWhenTest.java |   14 +-
 .../java/rx/schedulers/TestSchedulerTest.java |   66 +-
 src/test/java/rx/schedulers/TimeXTest.java    |   38 +-
 .../schedulers/TrampolineSchedulerTest.java   |   18 +-
 .../java/rx/subjects/AsyncSubjectTest.java    |   74 +-
 .../java/rx/subjects/BehaviorSubjectTest.java |  112 +-
 .../subjects/BufferUntilSubscriberTest.java   |   42 +-
 .../java/rx/subjects/PublishSubjectTest.java  |   80 +-
 .../ReplaySubjectBoundedConcurrencyTest.java  |   52 +-
 .../ReplaySubjectConcurrencyTest.java         |   44 +-
 .../java/rx/subjects/ReplaySubjectTest.java   |  276 +--
 .../rx/subjects/SerializedSubjectTest.java    |    8 +-
 .../CompositeSubscriptionTest.java            |   18 +-
 .../MultipleAssignmentSubscriptionTest.java   |    6 +-
 .../RefCountSubscriptionTest.java             |    6 +-
 .../SerialSubscriptionTests.java              |    6 +-
 .../rx/subscriptions/SubscriptionsTest.java   |    6 +-
 src/test/java/rx/test/OperatorTester.java     |   12 +-
 .../rx/test/TestObstructionDetection.java     |   10 +-
 .../rx/test/TestObstructionDetectionTest.java |   14 +-
 src/test/java/rx/util/AssertObservable.java   |   10 +-
 .../java/rx/util/AssertObservableTest.java    |    6 +-
 544 files changed, 10455 insertions(+), 10455 deletions(-)

diff --git a/src/main/java/rx/AsyncEmitter.java b/src/main/java/rx/AsyncEmitter.java
index aa577ada9d..29693b7e90 100644
--- a/src/main/java/rx/AsyncEmitter.java
+++ b/src/main/java/rx/AsyncEmitter.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -23,7 +23,7 @@
  * a resource with it and exposes the current number of downstream
  * requested amount.
  * <p>
- * The onNext, onError and onCompleted methods should be called 
+ * The onNext, onError and onCompleted methods should be called
  * in a sequential manner, just like the Observer's methods. The
  * other methods are threadsafe.
  *
@@ -39,7 +39,7 @@ public interface AsyncEmitter<T> extends Observer<T> {
      * @param s the subscription, null is allowed
      */
     void setSubscription(Subscription s);
-    
+
     /**
      * Sets a Cancellable on this emitter; any previous Subscription
      * or Cancellation will be unsubscribed/cancelled.
@@ -52,20 +52,20 @@ public interface AsyncEmitter<T> extends Observer<T> {
      * @return the current outstanding request amount
      */
     long requested();
-    
+
     /**
      * A functional interface that has a single close method
      * that can throw.
      */
     interface Cancellable {
-        
+
         /**
          * Cancel the action or free a resource.
          * @throws Exception on error
          */
         void cancel() throws Exception;
     }
-    
+
     /**
      * Options to handle backpressure in the emitter.
      */
diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index b45d0cd17e..6cf90313fa 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -32,14 +32,14 @@
 
 /**
  * Represents a deferred computation without any value but only indication for completion or exception.
- * 
+ *
  * The class follows a similar event pattern as Reactive-Streams: onSubscribe (onError|onComplete)?
  */
 @Experimental
 public class Completable {
     /** The actual subscription action. */
     private final OnSubscribe onSubscribe;
-    
+
     /**
      * @deprecated Use {@link OnSubscribe} instead.
      */
@@ -61,7 +61,7 @@ public void call(final rx.CompletableSubscriber s) {
      * Callback used for building deferred computations that takes a CompletableSubscriber.
      */
     public interface OnSubscribe extends Action1<rx.CompletableSubscriber> {
-        
+
     }
 
     /**
@@ -81,15 +81,15 @@ public rx.CompletableSubscriber call(final rx.CompletableSubscriber subscriber)
             }
         };
     }
-    
+
     /**
      * Convenience interface and callback used by the lift operator that given a child CompletableSubscriber,
      * return a parent CompletableSubscriber that does any kind of lifecycle-related transformations.
      */
     public interface Operator extends Func1<rx.CompletableSubscriber, rx.CompletableSubscriber> {
-        
+
     }
-    
+
     /**
      * @deprecated Use {@link rx.CompletableSubscriber} instead.
      */
@@ -99,13 +99,13 @@ public interface CompletableSubscriber {
          * Called once the deferred computation completes normally.
          */
         void onCompleted();
-        
+
         /**
          * Called once if the deferred computation 'throws' an exception.
          * @param e the exception, not null.
          */
         void onError(Throwable e);
-        
+
         /**
          * Called once by the Completable to set a Subscription on this instance which
          * then can be used to cancel the subscription at any time.
@@ -113,7 +113,7 @@ public interface CompletableSubscriber {
          */
         void onSubscribe(Subscription d);
     }
-    
+
     static rx.CompletableSubscriber fromOldSubscriber(final CompletableSubscriber subscriber) {
         requireNonNull(subscriber);
         return new rx.CompletableSubscriber() {
@@ -167,9 +167,9 @@ public interface CompletableTransformer extends Transformer {
      * Completable fluently.
      */
     public interface Transformer extends Func1<Completable, Completable> {
-        
+
     }
-    
+
     /** Single instance of a complete Completable. */
     static final Completable COMPLETE = new Completable(new OnSubscribe() {
         @Override
@@ -178,7 +178,7 @@ public void call(rx.CompletableSubscriber s) {
             s.onCompleted();
         }
     }, false); // hook is handled in complete()
-    
+
     /** Single instance of a never Completable. */
     static final Completable NEVER = new Completable(new OnSubscribe() {
         @Override
@@ -186,7 +186,7 @@ public void call(rx.CompletableSubscriber s) {
             s.onSubscribe(Subscriptions.unsubscribed());
         }
     }, false); // hook is handled in never()
-    
+
     /**
      * Returns a Completable which terminates as soon as one of the source Completables
      * terminates (normally or with an error) and cancels all other Completables.
@@ -202,7 +202,7 @@ public static Completable amb(final Completable... sources) {
         if (sources.length == 1) {
             return sources[0];
         }
-        
+
         return create(new OnSubscribe() {
             @Override
             public void call(final rx.CompletableSubscriber s) {
@@ -210,7 +210,7 @@ public void call(final rx.CompletableSubscriber s) {
                 s.onSubscribe(set);
 
                 final AtomicBoolean once = new AtomicBoolean();
-                
+
                 rx.CompletableSubscriber inner = new rx.CompletableSubscriber() {
                     @Override
                     public void onCompleted() {
@@ -234,9 +234,9 @@ public void onError(Throwable e) {
                     public void onSubscribe(Subscription d) {
                         set.add(d);
                     }
-                    
+
                 };
-                
+
                 for (Completable c : sources) {
                     if (set.isUnsubscribed()) {
                         return;
@@ -254,14 +254,14 @@ public void onSubscribe(Subscription d) {
                     if (once.get() || set.isUnsubscribed()) {
                         return;
                     }
-                    
+
                     // no need to have separate subscribers because inner is stateless
                     c.unsafeSubscribe(inner);
                 }
             }
         });
     }
-    
+
     /**
      * Returns a Completable which terminates as soon as one of the source Completables
      * terminates (normally or with an error) and cancels all other Completables.
@@ -271,7 +271,7 @@ public void onSubscribe(Subscription d) {
      */
     public static Completable amb(final Iterable<? extends Completable> sources) {
         requireNonNull(sources);
-        
+
         return create(new OnSubscribe() {
             @Override
             public void call(final rx.CompletableSubscriber s) {
@@ -279,23 +279,23 @@ public void call(final rx.CompletableSubscriber s) {
                 s.onSubscribe(set);
 
                 Iterator<? extends Completable> it;
-                
+
                 try {
                     it = sources.iterator();
                 } catch (Throwable e) {
                     s.onError(e);
                     return;
                 }
-                
+
                 if (it == null) {
                     s.onError(new NullPointerException("The iterator returned is null"));
                     return;
                 }
-                
+
                 boolean empty = true;
-                
+
                 final AtomicBoolean once = new AtomicBoolean();
-                
+
                 rx.CompletableSubscriber inner = new rx.CompletableSubscriber() {
                     @Override
                     public void onCompleted() {
@@ -319,16 +319,16 @@ public void onError(Throwable e) {
                     public void onSubscribe(Subscription d) {
                         set.add(d);
                     }
-                    
+
                 };
-                
+
                 for (;;) {
                     if (once.get() || set.isUnsubscribed()) {
                         return;
                     }
-                    
+
                     boolean b;
-                    
+
                     try {
                         b = it.hasNext();
                     } catch (Throwable e) {
@@ -340,22 +340,22 @@ public void onSubscribe(Subscription d) {
                         }
                         return;
                     }
-                    
+
                     if (!b) {
                         if (empty) {
                             s.onCompleted();
                         }
                         break;
                     }
-                    
+
                     empty = false;
-                    
+
                     if (once.get() || set.isUnsubscribed()) {
                         return;
                     }
 
                     Completable c;
-                    
+
                     try {
                         c = it.next();
                     } catch (Throwable e) {
@@ -367,7 +367,7 @@ public void onSubscribe(Subscription d) {
                         }
                         return;
                     }
-                    
+
                     if (c == null) {
                         NullPointerException npe = new NullPointerException("One of the sources is null");
                         if (once.compareAndSet(false, true)) {
@@ -378,21 +378,21 @@ public void onSubscribe(Subscription d) {
                         }
                         return;
                     }
-                    
+
                     if (once.get() || set.isUnsubscribed()) {
                         return;
                     }
-                    
+
                     // no need to have separate subscribers because inner is stateless
                     c.unsafeSubscribe(inner);
                 }
             }
         });
     }
-    
+
     /**
      * Returns a Completable instance that completes immediately when subscribed to.
-     * @return a Completable instance that completes immediately 
+     * @return a Completable instance that completes immediately
      */
     public static Completable complete() {
         OnSubscribe cos = RxJavaHooks.onCreate(COMPLETE.onSubscribe);
@@ -401,7 +401,7 @@ public static Completable complete() {
         }
         return new Completable(cos, false);
     }
-    
+
     /**
      * Returns a Completable which completes only when all sources complete, one after another.
      * @param sources the sources to concatenate
@@ -418,7 +418,7 @@ public static Completable concat(Completable... sources) {
         }
         return create(new CompletableOnSubscribeConcatArray(sources));
     }
-    
+
     /**
      * Returns a Completable which completes only when all sources complete, one after another.
      * @param sources the sources to concatenate
@@ -427,10 +427,10 @@ public static Completable concat(Completable... sources) {
      */
     public static Completable concat(Iterable<? extends Completable> sources) {
         requireNonNull(sources);
-        
+
         return create(new CompletableOnSubscribeConcatIterable(sources));
     }
-    
+
     /**
      * Returns a Completable which completes only when all sources complete, one after another.
      * @param sources the sources to concatenate
@@ -440,7 +440,7 @@ public static Completable concat(Iterable<? extends Completable> sources) {
     public static Completable concat(Observable<? extends Completable> sources) {
         return concat(sources, 2);
     }
-    
+
     /**
      * Returns a Completable which completes only when all sources complete, one after another.
      * @param sources the sources to concatenate
@@ -466,7 +466,7 @@ public static Completable concat(Observable<? extends Completable> sources, int
     public static Completable create(CompletableOnSubscribe onSubscribe) {
         return create(fromOldOnSubscribe(onSubscribe));
     }
-    
+
     /**
      * Constructs a Completable instance by wrapping the given onSubscribe callback.
      * @param onSubscribe the callback which will receive the CompletableSubscriber instances
@@ -478,14 +478,14 @@ public static Completable create(OnSubscribe onSubscribe) {
         requireNonNull(onSubscribe);
         try {
             return new Completable(onSubscribe);
-        } catch (NullPointerException ex) { // NOPMD 
+        } catch (NullPointerException ex) { // NOPMD
             throw ex;
         } catch (Throwable ex) {
             RxJavaHooks.onError(ex);
             throw toNpe(ex);
-        } 
+        }
     }
-    
+
     /**
      * Defers the subscription to a Completable instance returned by a supplier.
      * @param completableFunc0 the supplier that returns the Completable that will be subscribed to.
@@ -497,7 +497,7 @@ public static Completable defer(final Func0<? extends Completable> completableFu
             @Override
             public void call(rx.CompletableSubscriber s) {
                 Completable c;
-                
+
                 try {
                     c = completableFunc0.call();
                 } catch (Throwable e) {
@@ -505,18 +505,18 @@ public void call(rx.CompletableSubscriber s) {
                     s.onError(e);
                     return;
                 }
-                
+
                 if (c == null) {
                     s.onSubscribe(Subscriptions.unsubscribed());
                     s.onError(new NullPointerException("The completable returned is null"));
                     return;
                 }
-                
+
                 c.unsafeSubscribe(s);
             }
         });
     }
-    
+
     /**
      * Creates a Completable which calls the given error supplier for each subscriber
      * and emits its returned Throwable.
@@ -534,13 +534,13 @@ public static Completable error(final Func0<? extends Throwable> errorFunc0) {
             public void call(rx.CompletableSubscriber s) {
                 s.onSubscribe(Subscriptions.unsubscribed());
                 Throwable error;
-                
+
                 try {
                     error = errorFunc0.call();
                 } catch (Throwable e) {
                     error = e;
                 }
-                
+
                 if (error == null) {
                     error = new NullPointerException("The error supplied is null");
                 }
@@ -565,7 +565,7 @@ public void call(rx.CompletableSubscriber s) {
             }
         });
     }
-    
+
     /**
      * Returns a Completable instance that runs the given Action0 for each subscriber and
      * emits either an unchecked exception or simply completes.
@@ -594,7 +594,7 @@ public void call(rx.CompletableSubscriber s) {
             }
         });
     }
-    
+
     /**
      * Returns a Completable which when subscribed, executes the callable function, ignores its
      * normal result and emits onError or onCompleted only.
@@ -622,7 +622,7 @@ public void call(rx.CompletableSubscriber s) {
             }
         });
     }
-    
+
     /**
      * Provides an API (in a cold Completable) that bridges the Completable-reactive world
      * with the callback-based world.
@@ -637,20 +637,20 @@ public void call(rx.CompletableSubscriber s) {
      *         public void onEvent(Event e) {
      *             emitter.onCompleted();
      *         }
-     *         
+     *
      *         &#64;Override
      *         public void onFailure(Exception e) {
      *             emitter.onError(e);
      *         }
      *     };
-     *     
+     *
      *     AutoCloseable c = api.someMethod(listener);
-     *     
+     *
      *     emitter.setCancellation(c::close);
-     *     
+     *
      * });
      * </code></pre>
-     * <p>All of the CompletableEmitter's methods are thread-safe and ensure the 
+     * <p>All of the CompletableEmitter's methods are thread-safe and ensure the
      * Completable's protocol are held.
      * @param producer the callback invoked for each incoming CompletableSubscriber
      * @return the new Completable instance
@@ -660,7 +660,7 @@ public void call(rx.CompletableSubscriber s) {
     public static Completable fromEmitter(Action1<CompletableEmitter> producer) {
         return create(new CompletableFromEmitter(producer));
     }
-    
+
     /**
      * Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.
      * <p>
@@ -672,7 +672,7 @@ public static Completable fromFuture(Future<?> future) {
         requireNonNull(future);
         return fromObservable(Observable.from(future));
     }
-    
+
     /**
      * Returns a Completable instance that subscribes to the given flowable, ignores all values and
      * emits only the terminal event.
@@ -731,14 +731,14 @@ public void onError(Throwable e) {
                     public void onSuccess(Object value) {
                         s.onCompleted();
                     }
-                    
+
                 };
                 s.onSubscribe(te);
                 single.subscribe(te);
             }
         });
     }
-    
+
     /**
      * Returns a Completable instance that subscribes to all sources at once and
      * completes only when all source Completables complete or one of them emits an error.
@@ -756,7 +756,7 @@ public static Completable merge(Completable... sources) {
         }
         return create(new CompletableOnSubscribeMergeArray(sources));
     }
-    
+
     /**
      * Returns a Completable instance that subscribes to all sources at once and
      * completes only when all source Completables complete or one of them emits an error.
@@ -779,7 +779,7 @@ public static Completable merge(Iterable<? extends Completable> sources) {
     public static Completable merge(Observable<? extends Completable> sources) {
         return merge0(sources, Integer.MAX_VALUE, false);
     }
-    
+
     /**
      * Returns a Completable instance that keeps subscriptions to a limited number of sources at once and
      * completes only when all source Completables complete or one of them emits an error.
@@ -791,9 +791,9 @@ public static Completable merge(Observable<? extends Completable> sources) {
      */
     public static Completable merge(Observable<? extends Completable> sources, int maxConcurrency) {
         return merge0(sources, maxConcurrency, false);
-        
+
     }
-    
+
     /**
      * Returns a Completable instance that keeps subscriptions to a limited number of sources at once and
      * completes only when all source Completables terminate in one way or another, combining any exceptions
@@ -812,7 +812,7 @@ protected static Completable merge0(Observable<? extends Completable> sources, i
         }
         return create(new CompletableOnSubscribeMerge(sources, maxConcurrency, delayErrors));
     }
-    
+
     /**
      * Returns a Completable that subscribes to all Completables in the source array and delays
      * any error emitted by either the sources observable or any of the inner Completables until all of
@@ -851,10 +851,10 @@ public static Completable mergeDelayError(Observable<? extends Completable> sour
         return merge0(sources, Integer.MAX_VALUE, true);
     }
 
-    
+
     /**
-     * Returns a Completable that subscribes to a limited number of inner Completables at once in 
-     * the source sequence and delays any error emitted by either the sources 
+     * Returns a Completable that subscribes to a limited number of inner Completables at once in
+     * the source sequence and delays any error emitted by either the sources
      * observable or any of the inner Completables until all of
      * them terminate in a way or another.
      * @param sources the sequence of Completables
@@ -865,7 +865,7 @@ public static Completable mergeDelayError(Observable<? extends Completable> sour
     public static Completable mergeDelayError(Observable<? extends Completable> sources, int maxConcurrency) {
         return merge0(sources, maxConcurrency, true);
     }
-    
+
     /**
      * Returns a Completable that never calls onError or onComplete.
      * @return the singleton instance that never calls onError or onComplete
@@ -877,7 +877,7 @@ public static Completable never() {
         }
         return new Completable(cos, false);
     }
-    
+
     /**
      * Java 7 backport: throws a NullPointerException if o is null.
      * @param o the object to check
@@ -890,7 +890,7 @@ static <T> T requireNonNull(T o) {
         }
         return o;
     }
-    
+
     /**
      * Returns a Completable instance that fires its onComplete event after the given delay elapsed.
      * @param delay the delay time
@@ -900,7 +900,7 @@ static <T> T requireNonNull(T o) {
     public static Completable timer(long delay, TimeUnit unit) {
         return timer(delay, unit, Schedulers.computation());
     }
-    
+
     /**
      * Returns a Completable instance that fires its onCompleted event after the given delay elapsed
      * by using the supplied scheduler.
@@ -934,7 +934,7 @@ public void call() {
             }
         });
     }
-    
+
     /**
      * Creates a NullPointerException instance and sets the given Throwable as its initial cause.
      * @param ex the Throwable instance to use as cause, not null (not verified)
@@ -945,33 +945,33 @@ static NullPointerException toNpe(Throwable ex) {
         npe.initCause(ex);
         return npe;
     }
-    
+
     /**
-     * Returns a Completable instance which manages a resource along 
+     * Returns a Completable instance which manages a resource along
      * with a custom Completable instance while the subscription is active.
      * <p>
      * This overload performs an eager unsubscription before the terminal event is emitted.
-     * 
+     *
      * @param <R> the resource type
-     * @param resourceFunc0 the supplier that returns a resource to be managed. 
+     * @param resourceFunc0 the supplier that returns a resource to be managed.
      * @param completableFunc1 the function that given a resource returns a Completable instance that will be subscribed to
      * @param disposer the consumer that disposes the resource created by the resource supplier
      * @return the new Completable instance
      */
-    public static <R> Completable using(Func0<R> resourceFunc0, 
-            Func1<? super R, ? extends Completable> completableFunc1, 
+    public static <R> Completable using(Func0<R> resourceFunc0,
+            Func1<? super R, ? extends Completable> completableFunc1,
             Action1<? super R> disposer) {
         return using(resourceFunc0, completableFunc1, disposer, true);
     }
-    
+
     /**
-     * Returns a Completable instance which manages a resource along 
+     * Returns a Completable instance which manages a resource along
      * with a custom Completable instance while the subscription is active and performs eager or lazy
      * resource disposition.
      * <p>
      * If this overload performs a lazy unsubscription after the terminal event is emitted.
      * Exceptions thrown at this time will be delivered to RxJavaPlugins only.
-     * 
+     *
      * @param <R> the resource type
      * @param resourceFunc0 the supplier that returns a resource to be managed
      * @param completableFunc1 the function that given a resource returns a non-null
@@ -981,19 +981,19 @@ public static <R> Completable using(Func0<R> resourceFunc0,
      * resource is disposed after the terminal event has been emitted
      * @return the new Completable instance
      */
-    public static <R> Completable using(final Func0<R> resourceFunc0, 
-            final Func1<? super R, ? extends Completable> completableFunc1, 
-            final Action1<? super R> disposer, 
+    public static <R> Completable using(final Func0<R> resourceFunc0,
+            final Func1<? super R, ? extends Completable> completableFunc1,
+            final Action1<? super R> disposer,
             final boolean eager) {
         requireNonNull(resourceFunc0);
         requireNonNull(completableFunc1);
         requireNonNull(disposer);
-        
+
         return create(new OnSubscribe() {
             @Override
             public void call(final rx.CompletableSubscriber s) {
-                final R resource; // NOPMD 
-                
+                final R resource; // NOPMD
+
                 try {
                     resource = resourceFunc0.call();
                 } catch (Throwable e) {
@@ -1001,9 +1001,9 @@ public void call(final rx.CompletableSubscriber s) {
                     s.onError(e);
                     return;
                 }
-                
+
                 Completable cs;
-                
+
                 try {
                     cs = completableFunc1.call(resource);
                 } catch (Throwable e) {
@@ -1018,12 +1018,12 @@ public void call(final rx.CompletableSubscriber s) {
                         return;
                     }
                     Exceptions.throwIfFatal(e);
-                    
+
                     s.onSubscribe(Subscriptions.unsubscribed());
                     s.onError(e);
                     return;
                 }
-                
+
                 if (cs == null) {
                     try {
                         disposer.call(resource);
@@ -1038,9 +1038,9 @@ public void call(final rx.CompletableSubscriber s) {
                     s.onError(new NullPointerException("The completable supplied is null"));
                     return;
                 }
-                
+
                 final AtomicBoolean once = new AtomicBoolean();
-                
+
                 cs.unsafeSubscribe(new rx.CompletableSubscriber() {
                     Subscription d;
                     void dispose() {
@@ -1066,9 +1066,9 @@ public void onCompleted() {
                                 }
                             }
                         }
-                        
+
                         s.onCompleted();
-                        
+
                         if (!eager) {
                             dispose();
                         }
@@ -1085,14 +1085,14 @@ public void onError(Throwable e) {
                                 }
                             }
                         }
-                        
+
                         s.onError(e);
-                        
+
                         if (!eager) {
                             dispose();
                         }
                     }
-                    
+
                     @Override
                     public void onSubscribe(Subscription d) {
                         this.d = d;
@@ -1107,7 +1107,7 @@ public void call() {
             }
         });
     }
-    
+
     /**
      * Constructs a Completable instance with the given onSubscribe callback.
      * @param onSubscribe the callback that will receive CompletableSubscribers when they subscribe,
@@ -1160,7 +1160,7 @@ public final Completable ambWith(Completable other) {
         requireNonNull(other);
         return amb(this, other);
     }
-    
+
     /**
      * Subscribes to and awaits the termination of this Completable instance in a blocking manner and
      * rethrows any exception emitted.
@@ -1169,7 +1169,7 @@ public final Completable ambWith(Completable other) {
     public final void await() {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
-        
+
         unsafeSubscribe(new rx.CompletableSubscriber() {
 
             @Override
@@ -1187,9 +1187,9 @@ public void onError(Throwable e) {
             public void onSubscribe(Subscription d) {
                 // ignored
             }
-            
+
         });
-        
+
         if (cdl.getCount() == 0) {
             if (err[0] != null) {
                 Exceptions.propagate(err[0]);
@@ -1205,7 +1205,7 @@ public void onSubscribe(Subscription d) {
             Exceptions.propagate(err[0]);
         }
     }
-    
+
     /**
      * Subscribes to and awaits the termination of this Completable instance in a blocking manner
      * with a specific timeout and rethrows any exception emitted within the timeout window.
@@ -1217,10 +1217,10 @@ public void onSubscribe(Subscription d) {
      */
     public final boolean await(long timeout, TimeUnit unit) {
         requireNonNull(unit);
-        
+
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
-        
+
         unsafeSubscribe(new rx.CompletableSubscriber() {
 
             @Override
@@ -1238,9 +1238,9 @@ public void onError(Throwable e) {
             public void onSubscribe(Subscription d) {
                 // ignored
             }
-            
+
         });
-        
+
         if (cdl.getCount() == 0) {
             if (err[0] != null) {
                 Exceptions.propagate(err[0]);
@@ -1260,7 +1260,7 @@ public void onSubscribe(Subscription d) {
         }
         return b;
     }
-    
+
     /**
      * Calls the given transformer function with this instance and returns the function's resulting
      * Completable.
@@ -1271,13 +1271,13 @@ public void onSubscribe(Subscription d) {
     public final Completable compose(Transformer transformer) {
         return to(transformer);
     }
-    
+
     /**
-     * Returns an Observable which will subscribe to this Completable and once that is completed then 
-     * will subscribe to the {@code next} Observable. An error event from this Completable will be 
-     * propagated to the downstream subscriber and will result in skipping the subscription of the 
-     * Observable.  
-     * 
+     * Returns an Observable which will subscribe to this Completable and once that is completed then
+     * will subscribe to the {@code next} Observable. An error event from this Completable will be
+     * propagated to the downstream subscriber and will result in skipping the subscription of the
+     * Observable.
+     *
      * @param <T> the value type of the next Observable
      * @param next the Observable to subscribe after this Completable is completed, not null
      * @return Observable that composes this Completable and next
@@ -1319,7 +1319,7 @@ public final <T> Single<T> andThen(Single<T> next) {
     public final Completable andThen(Completable next) {
         return concatWith(next);
     }
-    
+
     /**
      * Concatenates this Completable with another Completable.
      * @param other the other Completable, not null
@@ -1341,7 +1341,7 @@ public final Completable concatWith(Completable other) {
     public final Completable delay(long delay, TimeUnit unit) {
         return delay(delay, unit, Schedulers.computation(), false);
     }
-    
+
     /**
      * Returns a Completable which delays the emission of the completion event by the given time while
      * running on the specified scheduler.
@@ -1354,7 +1354,7 @@ public final Completable delay(long delay, TimeUnit unit) {
     public final Completable delay(long delay, TimeUnit unit, Scheduler scheduler) {
         return delay(delay, unit, scheduler, false);
     }
-    
+
     /**
      * Returns a Completable which delays the emission of the completion event, and optionally the error as well, by the given time while
      * running on the specified scheduler.
@@ -1372,13 +1372,13 @@ public final Completable delay(final long delay, final TimeUnit unit, final Sche
             @Override
             public void call(final rx.CompletableSubscriber s) {
                 final CompositeSubscription set = new CompositeSubscription();
-                
+
                 final Scheduler.Worker w = scheduler.createWorker();
                 set.add(w);
-                
+
                 unsafeSubscribe(new rx.CompletableSubscriber() {
 
-                    
+
                     @Override
                     public void onCompleted() {
                         set.add(w.schedule(new Action0() {
@@ -1416,7 +1416,7 @@ public void onSubscribe(Subscription d) {
                         set.add(d);
                         s.onSubscribe(set);
                     }
-                    
+
                 });
             }
         });
@@ -1477,7 +1477,7 @@ public void call() {
     public final Completable doOnUnsubscribe(Action0 onUnsubscribe) {
         return doOnLifecycle(Actions.empty(), Actions.empty(), Actions.empty(), Actions.empty(), onUnsubscribe);
     }
-    
+
     /**
      * Returns a Completable which calls the given onError callback if this Completable emits an error.
      * @param onError the error callback
@@ -1499,9 +1499,9 @@ public final Completable doOnError(Action1<? super Throwable> onError) {
      * @return the new Completable instance
      */
     protected final Completable doOnLifecycle(
-            final Action1<? super Subscription> onSubscribe, 
-            final Action1<? super Throwable> onError, 
-            final Action0 onComplete, 
+            final Action1<? super Subscription> onSubscribe,
+            final Action1<? super Throwable> onError,
+            final Action0 onComplete,
             final Action0 onAfterComplete,
             final Action0 onUnsubscribe) {
         requireNonNull(onSubscribe);
@@ -1522,9 +1522,9 @@ public void onCompleted() {
                             s.onError(e);
                             return;
                         }
-                        
+
                         s.onCompleted();
-                        
+
                         try {
                             onAfterComplete.call();
                         } catch (Throwable e) {
@@ -1539,13 +1539,13 @@ public void onError(Throwable e) {
                         } catch (Throwable ex) {
                             e = new CompositeException(Arrays.asList(e, ex));
                         }
-                        
+
                         s.onError(e);
                     }
 
                     @Override
                     public void onSubscribe(final Subscription d) {
-                        
+
                         try {
                             onSubscribe.call(d);
                         } catch (Throwable ex) {
@@ -1554,7 +1554,7 @@ public void onSubscribe(final Subscription d) {
                             s.onError(ex);
                             return;
                         }
-                        
+
                         s.onSubscribe(Subscriptions.create(new Action0() {
                             @Override
                             public void call() {
@@ -1567,12 +1567,12 @@ public void call() {
                             }
                         }));
                     }
-                    
+
                 });
             }
         });
     }
-    
+
     /**
      * Returns a Completable instance that calls the given onSubscribe callback with the disposable
      * that child subscribers receive on subscription.
@@ -1583,7 +1583,7 @@ public void call() {
     public final Completable doOnSubscribe(Action1<? super Subscription> onSubscribe) {
         return doOnLifecycle(onSubscribe, Actions.empty(), Actions.empty(), Actions.empty(), Actions.empty());
     }
-    
+
     /**
      * Returns a Completable instance that calls the given onTerminate callback just before this Completable
      * completes normally or with an exception
@@ -1598,7 +1598,7 @@ public void call(Throwable e) {
             }
         }, onTerminate, Actions.empty(), Actions.empty());
     }
-    
+
     /**
      * Returns a completable that first runs this Completable
      * and then the other completable.
@@ -1613,7 +1613,7 @@ public void call(Throwable e) {
     public final Completable endWith(Completable other) {
         return andThen(other);
     }
-    
+
     /**
      * Returns an Observable that first runs this Completable instance and
      * resumes with the given next Observable.
@@ -1637,7 +1637,7 @@ public final <T> Observable<T> endWith(Observable<T> next) {
     public final Completable doAfterTerminate(Action0 onAfterComplete) {
         return doOnLifecycle(Actions.empty(), Actions.empty(), Actions.empty(), onAfterComplete, Actions.empty());
     }
-    
+
     /**
      * Subscribes to this Completable instance and blocks until it terminates, then returns null or
      * the emitted exception if any.
@@ -1647,7 +1647,7 @@ public final Completable doAfterTerminate(Action0 onAfterComplete) {
     public final Throwable get() {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
-        
+
         unsafeSubscribe(new rx.CompletableSubscriber() {
 
             @Override
@@ -1665,9 +1665,9 @@ public void onError(Throwable e) {
             public void onSubscribe(Subscription d) {
                 // ignored
             }
-            
+
         });
-        
+
         if (cdl.getCount() == 0) {
             return err[0];
         }
@@ -1678,9 +1678,9 @@ public void onSubscribe(Subscription d) {
         }
         return err[0];
     }
-    
+
     /**
-     * Subscribes to this Completable instance and blocks until it terminates or the specified timeout 
+     * Subscribes to this Completable instance and blocks until it terminates or the specified timeout
      * elapses, then returns null for normal termination or the emitted exception if any.
      * @param timeout the time amount to wait for the terminal event
      * @param unit the time unit of the timeout parameter
@@ -1690,10 +1690,10 @@ public void onSubscribe(Subscription d) {
      */
     public final Throwable get(long timeout, TimeUnit unit) {
         requireNonNull(unit);
-        
+
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] err = new Throwable[1];
-        
+
         unsafeSubscribe(new rx.CompletableSubscriber() {
 
             @Override
@@ -1711,9 +1711,9 @@ public void onError(Throwable e) {
             public void onSubscribe(Subscription d) {
                 // ignored
             }
-            
+
         });
-        
+
         if (cdl.getCount() == 0) {
             return err[0];
         }
@@ -1741,7 +1741,7 @@ public void onSubscribe(Subscription d) {
     public final Completable lift(CompletableOperator onLift) {
         return lift(fromOldOperator(onLift));
     }
-    
+
     /**
      * Lifts a CompletableSubscriber transformation into the chain of Completables.
      * @param onLift the lifting function that transforms the child subscriber with a parent subscriber.
@@ -1756,9 +1756,9 @@ public void call(rx.CompletableSubscriber s) {
                 try {
                     Operator onLiftDecorated = RxJavaHooks.onCompletableLift(onLift);
                     rx.CompletableSubscriber sw = onLiftDecorated.call(s);
-                    
+
                     unsafeSubscribe(sw);
-                } catch (NullPointerException ex) { // NOPMD 
+                } catch (NullPointerException ex) { // NOPMD
                     throw ex;
                 } catch (Throwable ex) {
                     throw toNpe(ex);
@@ -1778,7 +1778,7 @@ public final Completable mergeWith(Completable other) {
         requireNonNull(other);
         return merge(this, other);
     }
-    
+
     /**
      * Returns a Completable which emits the terminal events from the thread of the specified scheduler.
      * @param scheduler the scheduler to emit terminal events on
@@ -1790,14 +1790,14 @@ public final Completable observeOn(final Scheduler scheduler) {
         return create(new OnSubscribe() {
             @Override
             public void call(final rx.CompletableSubscriber s) {
-                
+
                 final SubscriptionList ad = new SubscriptionList();
-                
+
                 final Scheduler.Worker w = scheduler.createWorker();
                 ad.add(w);
-                
+
                 s.onSubscribe(ad);
-                
+
                 unsafeSubscribe(new rx.CompletableSubscriber() {
 
                     @Override
@@ -1832,12 +1832,12 @@ public void call() {
                     public void onSubscribe(Subscription d) {
                         ad.add(d);
                     }
-                    
+
                 });
             }
         });
     }
-    
+
     /**
      * Returns a Completable instance that if this Completable emits an error, it will emit an onComplete
      * and swallow the throwable.
@@ -1856,7 +1856,7 @@ public final Completable onErrorComplete() {
      */
     public final Completable onErrorComplete(final Func1<? super Throwable, Boolean> predicate) {
         requireNonNull(predicate);
-        
+
         return create(new OnSubscribe() {
             @Override
             public void call(final rx.CompletableSubscriber s) {
@@ -1870,7 +1870,7 @@ public void onCompleted() {
                     @Override
                     public void onError(Throwable e) {
                         boolean b;
-                        
+
                         try {
                             b = predicate.call(e);
                         } catch (Throwable ex) {
@@ -1878,7 +1878,7 @@ public void onError(Throwable e) {
                             e = new CompositeException(Arrays.asList(e, ex));
                             b = false;
                         }
-                        
+
                         if (b) {
                             s.onCompleted();
                         } else {
@@ -1890,12 +1890,12 @@ public void onError(Throwable e) {
                     public void onSubscribe(Subscription d) {
                         s.onSubscribe(d);
                     }
-                    
+
                 });
             }
         });
     }
-    
+
     /**
      * Returns a Completable instance that when encounters an error from this Completable, calls the
      * specified mapper function that returns another Completable instance for it and resumes the
@@ -1920,7 +1920,7 @@ public void onCompleted() {
                     @Override
                     public void onError(Throwable e) {
                         Completable c;
-                        
+
                         try {
                             c = errorMapper.call(e);
                         } catch (Throwable ex) {
@@ -1928,14 +1928,14 @@ public void onError(Throwable e) {
                             s.onError(e);
                             return;
                         }
-                        
+
                         if (c == null) {
                             NullPointerException npe = new NullPointerException("The completable returned is null");
                             e = new CompositeException(Arrays.asList(e, npe));
                             s.onError(e);
                             return;
                         }
-                        
+
                         c.unsafeSubscribe(new rx.CompletableSubscriber() {
 
                             @Override
@@ -1952,7 +1952,7 @@ public void onError(Throwable e) {
                             public void onSubscribe(Subscription d) {
                                 sd.set(d);
                             }
-                            
+
                         });
                     }
 
@@ -1960,12 +1960,12 @@ public void onSubscribe(Subscription d) {
                     public void onSubscribe(Subscription d) {
                         sd.set(d);
                     }
-                    
+
                 });
             }
         });
     }
-    
+
     /**
      * Returns a Completable that repeatedly subscribes to this Completable until cancelled.
      * @return the new Completable instance
@@ -1973,7 +1973,7 @@ public void onSubscribe(Subscription d) {
     public final Completable repeat() {
         return fromObservable(toObservable().repeat());
     }
-    
+
     /**
      * Returns a Completable that subscribes repeatedly at most the given times to this Completable.
      * @param times the number of times the resubscription should happen
@@ -1983,7 +1983,7 @@ public final Completable repeat() {
     public final Completable repeat(long times) {
         return fromObservable(toObservable().repeat(times));
     }
-    
+
     /**
      * Returns a Completable instance that repeats when the Publisher returned by the handler
      * emits an item or completes when this Publisher emits a completed event.
@@ -1997,7 +1997,7 @@ public final Completable repeatWhen(Func1<? super Observable<? extends Void>, ?
         requireNonNull(handler); // FIXME do a null check in Observable
         return fromObservable(toObservable().repeatWhen(handler));
     }
-    
+
     /**
      * Returns a Completable that retries this Completable as long as it emits an onError event.
      * @return the new Completable instance
@@ -2005,7 +2005,7 @@ public final Completable repeatWhen(Func1<? super Observable<? extends Void>, ?
     public final Completable retry() {
         return fromObservable(toObservable().retry());
     }
-    
+
     /**
      * Returns a Completable that retries this Completable in case of an error as long as the predicate
      * returns true.
@@ -2065,7 +2065,7 @@ public final <T> Observable<T> startWith(Observable<T> other) {
         requireNonNull(other);
         return this.<T>toObservable().startWith(other);
     }
-    
+
     /**
      * Subscribes to this Completable and returns a Subscription which can be used to cancel
      * the subscription.
@@ -2078,20 +2078,20 @@ public final Subscription subscribe() {
             public void onCompleted() {
                 mad.unsubscribe();
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 RxJavaHooks.onError(e);
                 mad.unsubscribe();
                 deliverUncaughtException(e);
             }
-            
+
             @Override
             public void onSubscribe(Subscription d) {
                 mad.set(d);
             }
         });
-        
+
         return mad;
     }
     /**
@@ -2104,7 +2104,7 @@ public void onSubscribe(Subscription d) {
      */
     public final Subscription subscribe(final Action0 onComplete) {
         requireNonNull(onComplete);
-        
+
         final MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
         unsafeSubscribe(new rx.CompletableSubscriber() {
             boolean done;
@@ -2122,26 +2122,26 @@ public void onCompleted() {
                     }
                 }
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 RxJavaHooks.onError(e);
                 mad.unsubscribe();
                 deliverUncaughtException(e);
             }
-            
+
             @Override
             public void onSubscribe(Subscription d) {
                 mad.set(d);
             }
         });
-        
+
         return mad;
     }
 
     /**
      * Subscribes to this Completable and calls back either the onError or onComplete functions.
-     * 
+     *
      * @param onComplete the runnable that is called if the Completable completes normally
      * @param onError the consumer that is called if this Completable emits an error
      * @return the Subscription that can be used for cancelling the subscription asynchronously
@@ -2150,7 +2150,7 @@ public void onSubscribe(Subscription d) {
     public final Subscription subscribe(final Action0 onComplete, final Action1<? super Throwable> onError) {
         requireNonNull(onComplete);
         requireNonNull(onError);
-        
+
         final MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
         unsafeSubscribe(new rx.CompletableSubscriber() {
             boolean done;
@@ -2167,7 +2167,7 @@ public void onCompleted() {
                     mad.unsubscribe();
                 }
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 if (!done) {
@@ -2178,7 +2178,7 @@ public void onError(Throwable e) {
                     deliverUncaughtException(e);
                 }
             }
-            
+
             void callOnError(Throwable e) {
                 try {
                     onError.call(e);
@@ -2190,13 +2190,13 @@ void callOnError(Throwable e) {
                     mad.unsubscribe();
                 }
             }
-            
+
             @Override
             public void onSubscribe(Subscription d) {
                 mad.set(d);
             }
         });
-        
+
         return mad;
     }
 
@@ -2225,9 +2225,9 @@ public final void unsafeSubscribe(rx.CompletableSubscriber s) {
         requireNonNull(s);
         try {
             OnSubscribe onSubscribeDecorated = RxJavaHooks.onCompletableStart(this, this.onSubscribe);
-            
+
             onSubscribeDecorated.call(s);
-        } catch (NullPointerException ex) { // NOPMD 
+        } catch (NullPointerException ex) { // NOPMD
             throw ex;
         } catch (Throwable ex) {
             Exceptions.throwIfFatal(ex);
@@ -2279,19 +2279,19 @@ private final <T> void unsafeSubscribe(final Subscriber<T> s, boolean callOnStar
                 public void onCompleted() {
                     s.onCompleted();
                 }
-                
+
                 @Override
                 public void onError(Throwable e) {
                     s.onError(e);
                 }
-                
+
                 @Override
                 public void onSubscribe(Subscription d) {
                     s.add(d);
                 }
             });
             RxJavaHooks.onObservableReturn(s);
-        } catch (NullPointerException ex) { // NOPMD 
+        } catch (NullPointerException ex) { // NOPMD
             throw ex;
         } catch (Throwable ex) {
             Exceptions.throwIfFatal(ex);
@@ -2326,14 +2326,14 @@ public final <T> void subscribe(Subscriber<T> s) {
      */
     public final Completable subscribeOn(final Scheduler scheduler) {
         requireNonNull(scheduler);
-        
+
         return create(new OnSubscribe() {
             @Override
             public void call(final rx.CompletableSubscriber s) {
                 // FIXME cancellation of this schedule
-                
+
                 final Scheduler.Worker w = scheduler.createWorker();
-                
+
                 w.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -2359,7 +2359,7 @@ public void call() {
     public final Completable timeout(long timeout, TimeUnit unit) {
         return timeout0(timeout, unit, Schedulers.computation(), null);
     }
-    
+
     /**
      * Returns a Completable that runs this Completable and switches to the other Completable
      * in case this Completable doesn't complete within the given time.
@@ -2373,7 +2373,7 @@ public final Completable timeout(long timeout, TimeUnit unit, Completable other)
         requireNonNull(other);
         return timeout0(timeout, unit, Schedulers.computation(), other);
     }
-    
+
     /**
      * Returns a Completable that runs this Completable and emits a TimeoutException in case
      * this Completable doesn't complete within the given time while "waiting" on the specified
@@ -2387,7 +2387,7 @@ public final Completable timeout(long timeout, TimeUnit unit, Completable other)
     public final Completable timeout(long timeout, TimeUnit unit, Scheduler scheduler) {
         return timeout0(timeout, unit, scheduler, null);
     }
-    
+
     /**
      * Returns a Completable that runs this Completable and switches to the other Completable
      * in case this Completable doesn't complete within the given time while "waiting" on
@@ -2403,7 +2403,7 @@ public final Completable timeout(long timeout, TimeUnit unit, Scheduler schedule
         requireNonNull(other);
         return timeout0(timeout, unit, scheduler, other);
     }
-    
+
     /**
      * Returns a Completable that runs this Completable and optionally switches to the other Completable
      * in case this Completable doesn't complete within the given time while "waiting" on
@@ -2411,7 +2411,7 @@ public final Completable timeout(long timeout, TimeUnit unit, Scheduler schedule
      * @param timeout the timeout value
      * @param unit the timeout unit
      * @param scheduler the scheduler to use to wait for completion
-     * @param other the other Completable instance to switch to in case of a timeout, 
+     * @param other the other Completable instance to switch to in case of a timeout,
      * if null a TimeoutException is emitted instead
      * @return the new Completable instance
      * @throws NullPointerException if unit or scheduler
@@ -2421,7 +2421,7 @@ public final Completable timeout0(long timeout, TimeUnit unit, Scheduler schedul
         requireNonNull(scheduler);
         return create(new CompletableOnSubscribeTimeout(this, timeout, unit, scheduler, other));
     }
-    
+
     /**
      * Calls the specified converter function during assembly time and returns its resulting value.
      * <p>
@@ -2448,7 +2448,7 @@ public void call(Subscriber<? super T> s) {
             }
         });
     }
-    
+
     /**
      * Converts this Completable into a Single which when this Completable completes normally,
      * calls the given supplier and emits its returned value through onSuccess.
@@ -2474,7 +2474,7 @@ public void onCompleted() {
                             s.onError(e);
                             return;
                         }
-                        
+
                         if (v == null) {
                             s.onError(new NullPointerException("The value supplied is null"));
                         } else {
@@ -2491,12 +2491,12 @@ public void onError(Throwable e) {
                     public void onSubscribe(Subscription d) {
                         s.add(d);
                     }
-                    
+
                 });
             }
         });
     }
-    
+
     /**
      * Converts this Completable into a Single which when this Completable completes normally,
      * emits the given value through onSuccess.
@@ -2514,9 +2514,9 @@ public T call() {
             }
         });
     }
-    
+
     /**
-     * Returns a Completable which makes sure when a subscriber cancels the subscription, the 
+     * Returns a Completable which makes sure when a subscriber cancels the subscription, the
      * dispose is called on the specified scheduler
      * @param scheduler the target scheduler where to execute the cancellation
      * @return the new Completable instance
@@ -2558,7 +2558,7 @@ public void call() {
                             }
                         }));
                     }
-                    
+
                 });
             }
         });
diff --git a/src/main/java/rx/CompletableEmitter.java b/src/main/java/rx/CompletableEmitter.java
index a2e7ccc125..fcbd1d0fa9 100644
--- a/src/main/java/rx/CompletableEmitter.java
+++ b/src/main/java/rx/CompletableEmitter.java
@@ -30,19 +30,19 @@
 public interface CompletableEmitter {
 
     /**
-     * Notifies the CompletableSubscriber that the {@link Completable} has finished 
+     * Notifies the CompletableSubscriber that the {@link Completable} has finished
      * sending push-based notifications.
      * <p>
      * The {@link Observable} will not call this method if it calls {@link #onError}.
      */
     void onCompleted();
-    
+
     /**
      * Notifies the CompletableSubscriber that the {@link Completable} has experienced an error condition.
      * <p>
      * If the {@link Completable} calls this method, it will not thereafter call
      * {@link #onCompleted}.
-     * 
+     *
      * @param t
      *          the exception encountered by the Observable
      */
@@ -54,7 +54,7 @@ public interface CompletableEmitter {
      * @param s the subscription, null is allowed
      */
     void setSubscription(Subscription s);
-    
+
     /**
      * Sets a Cancellable on this emitter; any previous Subscription
      * or Cancellation will be unsubscribed/cancelled.
diff --git a/src/main/java/rx/Notification.java b/src/main/java/rx/Notification.java
index 248820855d..d9c6e2fff5 100644
--- a/src/main/java/rx/Notification.java
+++ b/src/main/java/rx/Notification.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -84,7 +84,7 @@ private Notification(Kind kind, T value, Throwable e) {
 
     /**
      * Retrieves the exception associated with this (onError) notification.
-     * 
+     *
      * @return the Throwable associated with this (onError) notification
      */
     public Throwable getThrowable() {
@@ -93,7 +93,7 @@ public Throwable getThrowable() {
 
     /**
      * Retrieves the item associated with this (onNext) notification.
-     * 
+     *
      * @return the item associated with this (onNext) notification
      */
     public T getValue() {
@@ -102,7 +102,7 @@ public T getValue() {
 
     /**
      * Indicates whether this notification has an item associated with it.
-     * 
+     *
      * @return a boolean indicating whether or not this notification has an item associated with it
      */
     public boolean hasValue() {
@@ -112,7 +112,7 @@ public boolean hasValue() {
 
     /**
      * Indicates whether this notification has an exception associated with it.
-     * 
+     *
      * @return a boolean indicating whether this notification has an exception associated with it
      */
     public boolean hasThrowable() {
@@ -121,7 +121,7 @@ public boolean hasThrowable() {
 
     /**
      * Retrieves the kind of this notification: {@code OnNext}, {@code OnError}, or {@code OnCompleted}
-     * 
+     *
      * @return the kind of the notification: {@code OnNext}, {@code OnError}, or {@code OnCompleted}
      */
     public Kind getKind() {
@@ -130,7 +130,7 @@ public Kind getKind() {
 
     /**
      * Indicates whether this notification represents an {@code onError} event.
-     * 
+     *
      * @return a boolean indicating whether this notification represents an {@code onError} event
      */
     public boolean isOnError() {
@@ -139,7 +139,7 @@ public boolean isOnError() {
 
     /**
      * Indicates whether this notification represents an {@code onCompleted} event.
-     * 
+     *
      * @return a boolean indicating whether this notification represents an {@code onCompleted} event
      */
     public boolean isOnCompleted() {
@@ -148,7 +148,7 @@ public boolean isOnCompleted() {
 
     /**
      * Indicates whether this notification represents an {@code onNext} event.
-     * 
+     *
      * @return a boolean indicating whether this notification represents an {@code onNext} event
      */
     public boolean isOnNext() {
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 5d8d110917..79f19eb31f 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -1,11 +1,11 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -38,7 +38,7 @@
  * <p>
  * For more information see the <a href="http://reactivex.io/documentation/observable.html">ReactiveX
  * documentation</a>.
- * 
+ *
  * @param <T>
  *            the type of the items emitted by the Observable
  */
@@ -51,7 +51,7 @@ public class Observable<T> {
      * <p>
      * <em>Note:</em> Use {@link #create(OnSubscribe)} to create an Observable, instead of this constructor,
      * unless you specifically have a need for inheritance.
-     * 
+     *
      * @param f
      *            {@link OnSubscribe} to be executed when {@link #subscribe(Subscriber)} is called
      */
@@ -61,7 +61,7 @@ protected Observable(OnSubscribe<T> f) {
 
     /**
      * <strong>This method requires advanced knowledge about building operators and data sources; please consider
-     * other standard methods first;</strong> 
+     * other standard methods first;</strong>
      * Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to
      * it.
      * <p>
@@ -84,7 +84,7 @@ protected Observable(OnSubscribe<T> f) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T>
      *            the type of the items that this Observable emits
      * @param f
@@ -99,15 +99,15 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
     }
 
     /**
-     * Returns an Observable that respects the back-pressure semantics. When the returned Observable is 
-     * subscribed to it will initiate the given {@link SyncOnSubscribe}'s life cycle for 
-     * generating events. 
-     * 
-     * <p><b>Note:</b> the {@code SyncOnSubscribe} provides a generic way to fulfill data by iterating 
-     * over a (potentially stateful) function (e.g. reading data off of a channel, a parser, ). If your 
+     * Returns an Observable that respects the back-pressure semantics. When the returned Observable is
+     * subscribed to it will initiate the given {@link SyncOnSubscribe}'s life cycle for
+     * generating events.
+     *
+     * <p><b>Note:</b> the {@code SyncOnSubscribe} provides a generic way to fulfill data by iterating
+     * over a (potentially stateful) function (e.g. reading data off of a channel, a parser, ). If your
      * data comes directly from an asynchronous/potentially concurrent source then consider using the
      * {@link Observable#create(AsyncOnSubscribe) asynchronous overload}.
-     * 
+     *
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/create-sync.png" alt="">
      * <p>
@@ -119,13 +119,13 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T>
      *            the type of the items that this Observable emits
      * @param <S> the state type
      * @param syncOnSubscribe
-     *            an implementation of {@link SyncOnSubscribe}. There are many static creation methods 
-     *            on the class for convenience.  
+     *            an implementation of {@link SyncOnSubscribe}. There are many static creation methods
+     *            on the class for convenience.
      * @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the specified
      *         function
      * @see SyncOnSubscribe#createSingleState(Func0, Action2)
@@ -143,14 +143,14 @@ public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe)
     }
 
     /**
-     * Returns an Observable that respects the back-pressure semantics. When the returned Observable is 
-     * subscribed to it will initiate the given {@link AsyncOnSubscribe}'s life cycle for 
-     * generating events. 
-     * 
-     * <p><b>Note:</b> the {@code AsyncOnSubscribe} is useful for observable sources of data that are 
-     * necessarily asynchronous (RPC, external services, etc). Typically most use cases can be solved 
+     * Returns an Observable that respects the back-pressure semantics. When the returned Observable is
+     * subscribed to it will initiate the given {@link AsyncOnSubscribe}'s life cycle for
+     * generating events.
+     *
+     * <p><b>Note:</b> the {@code AsyncOnSubscribe} is useful for observable sources of data that are
+     * necessarily asynchronous (RPC, external services, etc). Typically most use cases can be solved
      * with the {@link Observable#create(SyncOnSubscribe) synchronous overload}.
-     * 
+     *
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/create-async.png" alt="">
      * <p>
@@ -162,13 +162,13 @@ public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe)
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T>
      *            the type of the items that this Observable emits
      * @param <S> the state type
      * @param asyncOnSubscribe
-     *            an implementation of {@link AsyncOnSubscribe}. There are many static creation methods 
-     *            on the class for convenience. 
+     *            an implementation of {@link AsyncOnSubscribe}. There are many static creation methods
+     *            on the class for convenience.
      * @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the specified
      *         function
      * @see AsyncOnSubscribe#createSingleState(Func0, Action3)
@@ -205,8 +205,8 @@ public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<
     /**
      * Passes all emitted values from this Observable to the provided conversion function to be collected and
      * returned as a single value. Note that it is legal for a conversion function to return an Observable
-     * (enabling chaining). 
-     * 
+     * (enabling chaining).
+     *
      * @param <R> the output type of the conversion function
      * @param conversion a function that converts from the source {@code Observable<T>} to an {@code R}
      * @return an instance of R created by the provided conversion function
@@ -216,10 +216,10 @@ public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<
     public <R> R extend(Func1<? super OnSubscribe<T>, ? extends R> conversion) {
         return conversion.call(new OnSubscribeExtend<T>(this));
     }
-    
+
     /**
      * Transforms a OnSubscribe.call() into an Observable.subscribe() call.
-     * <p>Note: has to be in Observable because it calls the package-private subscribe() method 
+     * <p>Note: has to be in Observable because it calls the package-private subscribe() method
      * @param <T> the value type
      */
     static final class OnSubscribeExtend<T> implements OnSubscribe<T> {
@@ -232,7 +232,7 @@ public void call(Subscriber<? super T> subscriber) {
             subscriber.add(subscribe(subscriber, parent));
         }
     }
-    
+
     /**
      * <strong>This method requires advanced knowledge about building operators; please consider
      * other standard composition methods first;</strong>
@@ -256,7 +256,7 @@ public void call(Subscriber<? super T> subscriber) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code lift} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the output value type
      * @param operator the Operator that implements the Observable-operating function to be applied to the source
      *             Observable
@@ -266,7 +266,7 @@ public void call(Subscriber<? super T> subscriber) {
     public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
         return create(new OnSubscribeLift<T, R>(onSubscribe, operator));
     }
-    
+
     /**
      * Transform an Observable by applying a particular Transformer function to it.
      * <p>
@@ -283,7 +283,7 @@ public final <R> Observable<R> lift(final Operator<? extends R, ? super T> opera
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code compose} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the value type of the output Observable
      * @param transformer implements the function that transforms the source Observable
      * @return the source Observable, transformed by the transformer function
@@ -301,7 +301,7 @@ public <R> Observable<R> compose(Transformer<? super T, ? extends R> transformer
      * <p>
      * This convenience interface has been introduced to work around the variance declaration
      * problems of type arguments.
-     * 
+     *
      * @param <T> the input Observable's value type
      * @param <R> the output Observable's value type
      */
@@ -330,7 +330,7 @@ public final <R> R to(Func1<? super Observable<T>, R> converter) {
      * <img width="640" height="295" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Single.toSingle.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator ignores backpressure on the source {@code Observable} and the returned {@code Single} 
+     *  <dd>The operator ignores backpressure on the source {@code Observable} and the returned {@code Single}
      *  does not have a notion of backpressure.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toSingle} does not operate by default on a particular {@link Scheduler}.</dd>
@@ -359,7 +359,7 @@ public Single<T> toSingle() {
      * alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator ignores backpressure on the source {@code Observable} and the returned {@code Completable} 
+     *  <dd>The operator ignores backpressure on the source {@code Observable} and the returned {@code Completable}
      *  does not have a notion of backpressure.</dd>
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code toCompletable} does not operate by default on a particular {@link Scheduler}.</dd>
@@ -376,7 +376,7 @@ public Single<T> toSingle() {
     public Completable toCompletable() {
         return Completable.fromObservable(this);
     }
-    
+
 
     /* *********************************************************************************************************
      * Operators Below Here
@@ -395,7 +395,7 @@ public Completable toCompletable() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element type
      * @param sources
      *            an Iterable of Observable sources competing to react first
@@ -419,7 +419,7 @@ public static <T> Observable<T> amb(Iterable<? extends Observable<? extends T>>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element type
      * @param o1
      *            an Observable competing to react first
@@ -445,7 +445,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param o1
      *            an Observable competing to react first
@@ -473,7 +473,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param o1
      *            an Observable competing to react first
@@ -535,7 +535,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param o1
      *            an Observable competing to react first
@@ -643,7 +643,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param o1
      *            an Observable competing to react first
@@ -718,7 +718,7 @@ public static <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the element type of the first source
      * @param <T2> the element type of the second source
      * @param <T3> the element type of the third source
@@ -754,7 +754,7 @@ public static <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the element type of the first source
      * @param <T2> the element type of the second source
      * @param <T3> the element type of the third source
@@ -794,7 +794,7 @@ public static <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? exten
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the element type of the first source
      * @param <T2> the element type of the second source
      * @param <T3> the element type of the third source
@@ -837,7 +837,7 @@ public static <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the element type of the first source
      * @param <T2> the element type of the second source
      * @param <T3> the element type of the third source
@@ -883,7 +883,7 @@ public static <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the element type of the first source
      * @param <T2> the element type of the second source
      * @param <T3> the element type of the third source
@@ -932,7 +932,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observ
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the element type of the first source
      * @param <T2> the element type of the second source
      * @param <T3> the element type of the third source
@@ -984,7 +984,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Ob
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code combineLatest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the element type of the first source
      * @param <T2> the element type of the second source
      * @param <T3> the element type of the third source
@@ -1088,7 +1088,7 @@ public static <T, R> Observable<R> combineLatest(Iterable<? extends Observable<?
      * the source Observables each time an item is received from any of the source Observables, where this
      * aggregation is defined by a specified function and delays any error from the sources until
      * all source Observables terminate.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The returned {@code Observable} honors backpressure from downstream. The source {@code Observable}s
@@ -1148,7 +1148,7 @@ public static <T> Observable<T> concat(Iterable<? extends Observable<? extends T
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. Both the outer and inner {@code Observable}
-     *  sources are expected to honor backpressure as well. If the outer violates this, a 
+     *  sources are expected to honor backpressure as well. If the outer violates this, a
      *  {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates
      *  this, it <em>may</em> throw an {@code IllegalStateException} when an inner {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -1175,7 +1175,7 @@ public static <T> Observable<T> concat(Observable<? extends Observable<? extends
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -1203,7 +1203,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -1233,13 +1233,13 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be concatenated
@@ -1265,7 +1265,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -1299,7 +1299,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -1335,7 +1335,7 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -1373,13 +1373,13 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be concatenated
@@ -1413,13 +1413,13 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be concatenated
@@ -1450,14 +1450,14 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
     /**
      * Concatenates the Observable sequence of Observables into a single sequence by subscribing to each inner Observable,
      * one after the other, one at a time and delays any errors till the all inner and the outer Observables terminate.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>{@code concatDelayError} fully supports backpressure.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param sources the Observable sequence of Observables
      * @return the new Observable with the concatenating behavior
@@ -1471,17 +1471,17 @@ public static <T> Observable<T> concatDelayError(Observable<? extends Observable
     /**
      * Concatenates the Iterable sequence of Observables into a single sequence by subscribing to each Observable,
      * one after the other, one at a time and delays any errors till the all inner Observables terminate.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. Both the outer and inner {@code Observable}
-     *  sources are expected to honor backpressure as well. If the outer violates this, a 
+     *  sources are expected to honor backpressure as well. If the outer violates this, a
      *  {@code MissingBackpressureException} is signalled. If any of the inner {@code Observable}s violates
      *  this, it <em>may</em> throw an {@code IllegalStateException} when an inner {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concatDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param sources the Iterable sequence of Observables
      * @return the new Observable with the concatenating behavior
@@ -1772,7 +1772,7 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code defer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param observableFactory
      *            the Observable factory function to invoke for each {@link Observer} that subscribes to the
      *            resulting Observable
@@ -1819,7 +1819,7 @@ public static <T> Observable<T> empty() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code error} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param exception
      *            the particular Throwable to pass to {@link Observer#onError onError}
      * @param <T>
@@ -1848,7 +1848,7 @@ public static <T> Observable<T> error(Throwable exception) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code from} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param future
      *            the source {@link Future}
      * @param <T>
@@ -1878,7 +1878,7 @@ public static <T> Observable<T> from(Future<? extends T> future) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code from} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param future
      *            the source {@link Future}
      * @param timeout
@@ -1910,7 +1910,7 @@ public static <T> Observable<T> from(Future<? extends T> future, long timeout, T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param future
      *            the source {@link Future}
      * @param scheduler
@@ -1940,7 +1940,7 @@ public static <T> Observable<T> from(Future<? extends T> future, Scheduler sched
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code from} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param iterable
      *            the source {@link Iterable} sequence
      * @param <T>
@@ -1964,7 +1964,7 @@ public static <T> Observable<T> from(Iterable<? extends T> iterable) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code from} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param array
      *            the source Array
      * @param <T>
@@ -1998,23 +1998,23 @@ public static <T> Observable<T> from(T[] array) {
      *                 emitter.onCompleted();
      *             }
      *         }
-     *         
+     *
      *         &#64;Override
      *         public void onFailure(Exception e) {
      *             emitter.onError(e);
      *         }
      *     };
-     *     
+     *
      *     AutoCloseable c = api.someMethod(listener);
-     *     
+     *
      *     emitter.setCancellation(c::close);
-     *     
+     *
      * }, BackpressureMode.BUFFER);
      * </code></pre>
      * <p>
      * You should call the AsyncEmitter's onNext, onError and onCompleted methods in a serialized fashion. The
      * rest of its methods are threadsafe.
-     * 
+     *
      * @param <T> the element type
      * @param asyncEmitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
      * @param backpressure the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
@@ -2029,7 +2029,7 @@ public static <T> Observable<T> from(T[] array) {
     public static <T> Observable<T> fromAsync(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) {
         return fromEmitter(asyncEmitter, backpressure);
     }
-    
+
     /**
      * Provides an API (via a cold Observable) that bridges the reactive world with the callback-style,
      * generally non-backpressured world.
@@ -2045,23 +2045,23 @@ public static <T> Observable<T> fromAsync(Action1<AsyncEmitter<T>> asyncEmitter,
      *                 emitter.onCompleted();
      *             }
      *         }
-     *         
+     *
      *         &#64;Override
      *         public void onFailure(Exception e) {
      *             emitter.onError(e);
      *         }
      *     };
-     *     
+     *
      *     AutoCloseable c = api.someMethod(listener);
-     *     
+     *
      *     emitter.setCancellation(c::close);
-     *     
+     *
      * }, BackpressureMode.BUFFER);
      * </code></pre>
      * <p>
      * You should call the AsyncEmitter's onNext, onError and onCompleted methods in a serialized fashion. The
      * rest of its methods are threadsafe.
-     * 
+     *
      * @param <T> the element type
      * @param emitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
      * @param backpressure the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
@@ -2075,7 +2075,7 @@ public static <T> Observable<T> fromAsync(Action1<AsyncEmitter<T>> asyncEmitter,
     public static <T> Observable<T> fromEmitter(Action1<AsyncEmitter<T>> emitter, AsyncEmitter.BackpressureMode backpressure) {
         return create(new OnSubscribeFromEmitter<T>(emitter, backpressure));
     }
-    
+
     /**
      * Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then
      * emits the value returned from that function.
@@ -2113,7 +2113,7 @@ public static <T> Observable<T> fromCallable(Callable<? extends T> func) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code interval} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param interval
      *            interval size in time units (see below)
      * @param unit
@@ -2138,7 +2138,7 @@ public static Observable<Long> interval(long interval, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param interval
      *            interval size in time units (see below)
      * @param unit
@@ -2165,7 +2165,7 @@ public static Observable<Long> interval(long interval, TimeUnit unit, Scheduler
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code interval} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param initialDelay
      *            the initial delay time to wait before emitting the first value of 0L
      * @param period
@@ -2194,7 +2194,7 @@ public static Observable<Long> interval(long initialDelay, long period, TimeUnit
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param initialDelay
      *            the initial delay time to wait before emitting the first value of 0L
      * @param period
@@ -2230,7 +2230,7 @@ public static Observable<Long> interval(long initialDelay, long period, TimeUnit
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param value
      *            the item to emit
      * @param <T>
@@ -2241,7 +2241,7 @@ public static Observable<Long> interval(long initialDelay, long period, TimeUnit
     public static <T> Observable<T> just(final T value) {
         return ScalarSynchronousObservable.create(value);
     }
-    
+
     /**
      * Converts two items into an Observable that emits those items.
      * <p>
@@ -2252,7 +2252,7 @@ public static <T> Observable<T> just(final T value) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            first item
      * @param t2
@@ -2278,7 +2278,7 @@ public static <T> Observable<T> just(T t1, T t2) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            first item
      * @param t2
@@ -2306,7 +2306,7 @@ public static <T> Observable<T> just(T t1, T t2, T t3) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            first item
      * @param t2
@@ -2368,7 +2368,7 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            first item
      * @param t2
@@ -2402,7 +2402,7 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            first item
      * @param t2
@@ -2438,7 +2438,7 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            first item
      * @param t2
@@ -2476,7 +2476,7 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            first item
      * @param t2
@@ -2516,7 +2516,7 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            first item
      * @param t2
@@ -2547,7 +2547,7 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
     public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9, T t10) {
         return from((T[])new Object[] { t1, t2, t3, t4, t5, t6, t7, t8, t9, t10 });
     }
-    
+
     /**
      * Flattens an Iterable of Observables into one Observable, without any transformation.
      * <p>
@@ -2562,7 +2562,7 @@ public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param sequences
      *            the Iterable of Observables
@@ -2589,7 +2589,7 @@ public static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param sequences
      *            the Iterable of Observables
@@ -2653,7 +2653,7 @@ public static <T> Observable<T> merge(Observable<? extends Observable<? extends
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param source
      *            an Observable that emits Observables
@@ -2688,7 +2688,7 @@ public static <T> Observable<T> merge(Observable<? extends Observable<? extends
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -2716,7 +2716,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -2746,7 +2746,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -2778,7 +2778,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -2812,7 +2812,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -2848,7 +2848,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -2886,7 +2886,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -2926,7 +2926,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -2968,7 +2968,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param sequences
      *            the Array of Observables
@@ -2978,7 +2978,7 @@ public static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? e
     public static <T> Observable<T> merge(Observable<? extends T>[] sequences) {
         return merge(from(sequences));
     }
-    
+
     /**
      * Flattens an Array of Observables into one Observable, without any transformation, while limiting the
      * number of concurrent subscriptions to these Observables.
@@ -2994,7 +2994,7 @@ public static <T> Observable<T> merge(Observable<? extends T>[] sequences) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param sequences
      *            the Array of Observables
@@ -3029,7 +3029,7 @@ public static <T> Observable<T> merge(Observable<? extends T>[] sequences, int m
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param source
      *            an Observable that emits Observables
@@ -3062,7 +3062,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends Observable<
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param source
      *            an Observable that emits Observables
@@ -3095,7 +3095,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends Observable<
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param sequences
      *            the Iterable of Observables
@@ -3124,7 +3124,7 @@ public static <T> Observable<T> mergeDelayError(Iterable<? extends Observable<?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param sequences
      *            the Iterable of Observables
@@ -3159,7 +3159,7 @@ public static <T> Observable<T> mergeDelayError(Iterable<? extends Observable<?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -3193,7 +3193,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -3229,7 +3229,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -3267,7 +3267,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -3307,7 +3307,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -3350,7 +3350,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -3394,7 +3394,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -3440,7 +3440,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common element base type
      * @param t1
      *            an Observable to be merged
@@ -3478,7 +3478,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Obse
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code nest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits a single item: the source Observable
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
@@ -3498,7 +3498,7 @@ public final Observable<Observable<T>> nest() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code never} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T>
      *            the type of items (not) emitted by the Observable
      * @return an Observable that never emits any items or sends any notifications to an {@link Observer}
@@ -3518,7 +3518,7 @@ public static <T> Observable<T> never() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code range} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param start
      *            the value of the first Integer in the sequence
      * @param count
@@ -3556,7 +3556,7 @@ public static Observable<Integer> range(int start, int count) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param start
      *            the value of the first Integer in the sequence
      * @param count
@@ -3579,7 +3579,7 @@ public static Observable<Integer> range(int start, int count, Scheduler schedule
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code sequenceEqual} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param first
      *            the first Observable to compare
      * @param second
@@ -3592,7 +3592,7 @@ public static Observable<Integer> range(int start, int count, Scheduler schedule
     public static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second) {
         return sequenceEqual(first, second, InternalObservableUtils.OBJECT_EQUALS);
     }
-    
+
     /**
      * Returns an Observable that emits a Boolean value that indicates whether two Observable sequences are the
      * same by comparing the items emitted by each Observable pairwise based on the results of a specified
@@ -3606,7 +3606,7 @@ public static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> firs
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code sequenceEqual} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param first
      *            the first Observable to compare
      * @param second
@@ -3645,7 +3645,7 @@ public static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> firs
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code switchOnNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the item type
      * @param sequenceOfSequences
      *            the source Observable that emits Observables
@@ -3680,7 +3680,7 @@ public static <T> Observable<T> switchOnNext(Observable<? extends Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code switchOnNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the item type
      * @param sequenceOfSequences
      *            the source Observable that emits Observables
@@ -3707,7 +3707,7 @@ public static <T> Observable<T> switchOnNextDelayError(Observable<? extends Obse
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code timer} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param initialDelay
      *            the initial delay time to wait before emitting the first value of 0L
      * @param period
@@ -3736,7 +3736,7 @@ public static Observable<Long> timer(long initialDelay, long period, TimeUnit un
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param initialDelay
      *            the initial delay time to wait before emitting the first value of 0L
      * @param period
@@ -3766,7 +3766,7 @@ public static Observable<Long> timer(long initialDelay, long period, TimeUnit un
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code timer} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param delay
      *            the initial delay before emitting a single {@code 0L}
      * @param unit
@@ -3790,7 +3790,7 @@ public static Observable<Long> timer(long delay, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param delay
      *            the initial delay before emitting a single 0L
      * @param unit
@@ -3811,12 +3811,12 @@ public static Observable<Long> timer(long delay, TimeUnit unit, Scheduler schedu
      * <img width="640" height="400" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/using.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator is a pass-through for backpressure and otherwise depends on the 
+     *  <dd>The operator is a pass-through for backpressure and otherwise depends on the
      *  backpressure support of the Observable returned by the {@code resourceFactory}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code using} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the element type of the generated Observable
      * @param <Resource> the type of the resource associated with the output sequence
      * @param resourceFactory
@@ -3834,9 +3834,9 @@ public static <T, Resource> Observable<T> using(
             final Action1<? super Resource> disposeAction) {
         return using(resourceFactory, observableFactory, disposeAction, false);
     }
-    
+
     /**
-     * Constructs an Observable that creates a dependent resource object which is disposed of just before 
+     * Constructs an Observable that creates a dependent resource object which is disposed of just before
      * termination if you have set {@code disposeEagerly} to {@code true} and unsubscription does not occur
      * before termination. Otherwise resource disposal will occur on unsubscription.  Eager disposal is
      * particularly appropriate for a synchronous Observable that reuses resources. {@code disposeAction} will
@@ -3845,12 +3845,12 @@ public static <T, Resource> Observable<T> using(
      * <img width="640" height="400" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/using.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator is a pass-through for backpressure and otherwise depends on the 
+     *  <dd>The operator is a pass-through for backpressure and otherwise depends on the
      *  backpressure support of the Observable returned by the {@code resourceFactory}.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code using} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the element type of the generated Observable
      * @param <Resource> the type of the resource associated with the output sequence
      * @param resourceFactory
@@ -3860,7 +3860,7 @@ public static <T, Resource> Observable<T> using(
      * @param disposeAction
      *            the function that will dispose of the resource
      * @param disposeEagerly
-     *            if {@code true} then disposal will happen either on unsubscription or just before emission of 
+     *            if {@code true} then disposal will happen either on unsubscription or just before emission of
      *            a terminal event ({@code onComplete} or {@code onError}).
      * @return the Observable whose lifetime controls the lifetime of the dependent resource object
      * @see <a href="http://reactivex.io/documentation/operators/using.html">ReactiveX operators documentation: Using</a>
@@ -3887,16 +3887,16 @@ public static <T, Resource> Observable<T> using(
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@code onNext} as many times as
      * the number of {@code onNext} invocations of the source Observable that emits the fewest items.
      * <p>
-     * The operator subscribes to its sources in order they are specified and completes eagerly if 
-     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
-     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
      * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
      * source A completes and B has been consumed and is about to complete, the operator detects A won't
      * be sending further values and it will unsubscribe B immediately. For example:
      * <pre><code>zip(Arrays.asList(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2)), (a) -&gt; a)</code></pre>
      * {@code action1} will be called but {@code action2} won't.
      * <br>To work around this termination property,
-     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
      * or unsubscription.
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/zip.png" alt="">
@@ -3908,7 +3908,7 @@ public static <T, Resource> Observable<T> using(
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the zipped result type
      * @param ws
      *            an Iterable of source Observables
@@ -3960,7 +3960,7 @@ public static <R> Observable<R> zip(Iterable<? extends Observable<?>> ws, FuncN<
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the result type
      * @param ws
      *            an array of source Observables
@@ -3987,16 +3987,16 @@ public static <R> Observable<R> zip(Observable<?>[] ws, FuncN<? extends R> zipFu
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@code onNext} as many times as
      * the number of {@code onNext} invocations of the source Observable that emits the fewest items.
      * <p>
-     * The operator subscribes to its sources in order they are specified and completes eagerly if 
-     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
-     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
      * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
      * source A completes and B has been consumed and is about to complete, the operator detects A won't
      * be sending further values and it will unsubscribe B immediately. For example:
      * <pre><code>zip(just(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2)), (a) -&gt; a)</code></pre>
      * {@code action1} will be called but {@code action2} won't.
      * <br>To work around this termination property,
-     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
      * or unsubscription.
      * <p>
      * <img width="640" height="370" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/zip.o.png" alt="">
@@ -4008,7 +4008,7 @@ public static <R> Observable<R> zip(Observable<?>[] ws, FuncN<? extends R> zipFu
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the zipped result type
      * @param ws
      *            an Observable of source Observables
@@ -4021,7 +4021,7 @@ public static <R> Observable<R> zip(Observable<?>[] ws, FuncN<? extends R> zipFu
     public static <R> Observable<R> zip(Observable<? extends Observable<?>> ws, final FuncN<? extends R> zipFunction) {
         return ws.toList().map(InternalObservableUtils.TO_ARRAY).lift(new OperatorZip<R>(zipFunction));
     }
-    
+
     /**
      * Returns an Observable that emits the results of a specified combiner function applied to combinations of
      * two items emitted, in sequence, by two other Observables.
@@ -4037,16 +4037,16 @@ public static <R> Observable<R> zip(Observable<? extends Observable<?>> ws, fina
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
      * <p>
-     * The operator subscribes to its sources in order they are specified and completes eagerly if 
-     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
-     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
      * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
      * source A completes and B has been consumed and is about to complete, the operator detects A won't
      * be sending further values and it will unsubscribe B immediately. For example:
      * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), (a, b) -&gt; a + b)</code></pre>
      * {@code action1} will be called but {@code action2} won't.
      * <br>To work around this termination property,
-     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
      * or unsubscription.
      * <dl>
      *  <dt><b>Backpressure:</b><dt>
@@ -4056,7 +4056,7 @@ public static <R> Observable<R> zip(Observable<? extends Observable<?>> ws, fina
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the value type of the first source
      * @param <T2> the value type of the second source
      * @param <R> the zipped result type
@@ -4090,16 +4090,16 @@ public static <T1, T2, R> Observable<R> zip(Observable<? extends T1> o1, Observa
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
      * <p>
-     * The operator subscribes to its sources in order they are specified and completes eagerly if 
-     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
-     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
      * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
      * source A completes and B has been consumed and is about to complete, the operator detects A won't
      * be sending further values and it will unsubscribe B immediately. For example:
      * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c) -&gt; a + b)</code></pre>
      * {@code action1} will be called but {@code action2} won't.
      * <br>To work around this termination property,
-     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
      * or unsubscription.
      * <dl>
      *  <dt><b>Backpressure:</b><dt>
@@ -4109,7 +4109,7 @@ public static <T1, T2, R> Observable<R> zip(Observable<? extends T1> o1, Observa
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the value type of the first source
      * @param <T2> the value type of the second source
      * @param <T3> the value type of the third source
@@ -4146,16 +4146,16 @@ public static <T1, T2, T3, R> Observable<R> zip(Observable<? extends T1> o1, Obs
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
      * <p>
-     * The operator subscribes to its sources in order they are specified and completes eagerly if 
-     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
-     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
      * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
      * source A completes and B has been consumed and is about to complete, the operator detects A won't
      * be sending further values and it will unsubscribe B immediately. For example:
      * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d) -&gt; a + b)</code></pre>
      * {@code action1} will be called but {@code action2} won't.
      * <br>To work around this termination property,
-     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
      * or unsubscription.
      * <dl>
      *  <dt><b>Backpressure:</b><dt>
@@ -4165,7 +4165,7 @@ public static <T1, T2, T3, R> Observable<R> zip(Observable<? extends T1> o1, Obs
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the value type of the first source
      * @param <T2> the value type of the second source
      * @param <T3> the value type of the third source
@@ -4205,16 +4205,16 @@ public static <T1, T2, T3, T4, R> Observable<R> zip(Observable<? extends T1> o1,
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
      * <p>
-     * The operator subscribes to its sources in order they are specified and completes eagerly if 
-     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
-     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
      * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
      * source A completes and B has been consumed and is about to complete, the operator detects A won't
      * be sending further values and it will unsubscribe B immediately. For example:
      * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d, e) -&gt; a + b)</code></pre>
      * {@code action1} will be called but {@code action2} won't.
      * <br>To work around this termination property,
-     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
      * or unsubscription.
      * <dl>
      *  <dt><b>Backpressure:</b><dt>
@@ -4224,7 +4224,7 @@ public static <T1, T2, T3, T4, R> Observable<R> zip(Observable<? extends T1> o1,
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the value type of the first source
      * @param <T2> the value type of the second source
      * @param <T3> the value type of the third source
@@ -4266,16 +4266,16 @@ public static <T1, T2, T3, T4, T5, R> Observable<R> zip(Observable<? extends T1>
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
      * <p>
-     * The operator subscribes to its sources in order they are specified and completes eagerly if 
-     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
-     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
      * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
      * source A completes and B has been consumed and is about to complete, the operator detects A won't
      * be sending further values and it will unsubscribe B immediately. For example:
      * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d, e, f) -&gt; a + b)</code></pre>
      * {@code action1} will be called but {@code action2} won't.
      * <br>To work around this termination property,
-     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
      * or unsubscription.
      * <dl>
      *  <dt><b>Backpressure:</b><dt>
@@ -4285,7 +4285,7 @@ public static <T1, T2, T3, T4, T5, R> Observable<R> zip(Observable<? extends T1>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the value type of the first source
      * @param <T2> the value type of the second source
      * @param <T3> the value type of the third source
@@ -4331,16 +4331,16 @@ public static <T1, T2, T3, T4, T5, T6, R> Observable<R> zip(Observable<? extends
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
      * <p>
-     * The operator subscribes to its sources in order they are specified and completes eagerly if 
-     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
-     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
      * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
      * source A completes and B has been consumed and is about to complete, the operator detects A won't
      * be sending further values and it will unsubscribe B immediately. For example:
      * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d, e, f, g) -&gt; a + b)</code></pre>
      * {@code action1} will be called but {@code action2} won't.
      * <br>To work around this termination property,
-     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
      * or unsubscription.
      * <dl>
      *  <dt><b>Backpressure:</b><dt>
@@ -4350,7 +4350,7 @@ public static <T1, T2, T3, T4, T5, T6, R> Observable<R> zip(Observable<? extends
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the value type of the first source
      * @param <T2> the value type of the second source
      * @param <T3> the value type of the third source
@@ -4399,16 +4399,16 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> zip(Observable<? ext
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
      * <p>
-     * The operator subscribes to its sources in order they are specified and completes eagerly if 
-     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
-     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
      * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
      * source A completes and B has been consumed and is about to complete, the operator detects A won't
      * be sending further values and it will unsubscribe B immediately. For example:
      * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d, e, f, g, h) -&gt; a + b)</code></pre>
      * {@code action1} will be called but {@code action2} won't.
      * <br>To work around this termination property,
-     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
      * or unsubscription.
      * <dl>
      *  <dt><b>Backpressure:</b><dt>
@@ -4418,7 +4418,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> zip(Observable<? ext
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the value type of the first source
      * @param <T2> the value type of the second source
      * @param <T3> the value type of the third source
@@ -4470,16 +4470,16 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> zip(Observable<?
      * as many times as the number of {@code onNext} invocations of the source Observable that emits the fewest
      * items.
      * <p>
-     * The operator subscribes to its sources in order they are specified and completes eagerly if 
-     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
-     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
      * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
      * source A completes and B has been consumed and is about to complete, the operator detects A won't
      * be sending further values and it will unsubscribe B immediately. For example:
      * <pre><code>zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2), ..., (a, b, c, d, e, f, g, h, i) -&gt; a + b)</code></pre>
      * {@code action1} will be called but {@code action2} won't.
      * <br>To work around this termination property,
-     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
      * or unsubscription.
      * <dl>
      *  <dt><b>Backpressure:</b><dt>
@@ -4489,7 +4489,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> zip(Observable<?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the value type of the first source
      * @param <T2> the value type of the second source
      * @param <T3> the value type of the third source
@@ -4541,7 +4541,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> zip(Observab
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code all} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param predicate
      *            a function that evaluates an item and returns a Boolean
      * @return an Observable that emits {@code true} if all items emitted by the source Observable satisfy the
@@ -4551,7 +4551,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> zip(Observab
     public final Observable<Boolean> all(Func1<? super T, Boolean> predicate) {
         return lift(new OperatorAll<T>(predicate));
     }
-    
+
     /**
      * Mirrors the Observable (current or provided) that first either emits an item or sends a termination
      * notification.
@@ -4564,7 +4564,7 @@ public final Observable<Boolean> all(Func1<? super T, Boolean> predicate) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code amb} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            an Observable competing to react first
      * @return an Observable that emits the same sequence as whichever of the source Observables first
@@ -4586,7 +4586,7 @@ public final Observable<T> ambWith(Observable<? extends T> t1) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code asObservable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that hides the identity of this Observable
      */
     public final Observable<T> asObservable() {
@@ -4606,7 +4606,7 @@ public final Observable<T> asObservable() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <TClosing> the value type of the boundary-providing Observable
      * @param bufferClosingSelector
      *            a {@link Func0} that produces an Observable that governs the boundary between buffers.
@@ -4635,7 +4635,7 @@ public final <TClosing> Observable<List<T>> buffer(Func0<? extends Observable<?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum number of items in each buffer before it should be emitted
      * @return an Observable that emits connected, non-overlapping buffers, each containing at most
@@ -4661,7 +4661,7 @@ public final Observable<List<T>> buffer(int count) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum size of each buffer before it should be emitted
      * @param skip
@@ -4691,7 +4691,7 @@ public final Observable<List<T>> buffer(int count, int skip) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code buffer} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each buffer collects items before it is emitted
      * @param timeshift
@@ -4721,7 +4721,7 @@ public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each buffer collects items before it is emitted
      * @param timeshift
@@ -4752,7 +4752,7 @@ public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code buffer} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each buffer collects items before it is emitted and replaced with a new
      *            buffer
@@ -4781,7 +4781,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code buffer} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each buffer collects items before it is emitted and replaced with a new
      *            buffer
@@ -4814,7 +4814,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count)
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each buffer collects items before it is emitted and replaced with a new
      *            buffer
@@ -4848,7 +4848,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count,
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each buffer collects items before it is emitted and replaced with a new
      *            buffer
@@ -4877,7 +4877,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <TOpening> the element type of the buffer-opening Observable
      * @param <TClosing> the element type of the individual buffer-closing Observables
      * @param bufferOpenings
@@ -4909,7 +4909,7 @@ public final <TOpening, TClosing> Observable<List<T>> buffer(Observable<? extend
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <B>
      *            the boundary value type (ignored)
      * @param boundary
@@ -4939,7 +4939,7 @@ public final <B> Observable<List<T>> buffer(Observable<B> boundary) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code buffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <B>
      *            the boundary value type (ignored)
      * @param boundary
@@ -4956,7 +4956,7 @@ public final <B> Observable<List<T>> buffer(Observable<B> boundary, int initialC
     }
 
     /**
-     * Returns an Observable that subscribes to this Observable lazily, caches all of its events 
+     * Returns an Observable that subscribes to this Observable lazily, caches all of its events
      * and replays them, in the same order as received, to all the downstream subscribers.
      * <p>
      * <img width="640" height="410" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/cache.png" alt="">
@@ -4966,16 +4966,16 @@ public final <B> Observable<List<T>> buffer(Observable<B> boundary, int initialC
      * <p>
      * The operator subscribes only when the first downstream subscriber subscribes and maintains
      * a single subscription towards this Observable. In contrast, the operator family of {@link #replay()}
-     * that return a {@link ConnectableObservable} require an explicit call to {@link ConnectableObservable#connect()}.  
+     * that return a {@link ConnectableObservable} require an explicit call to {@link ConnectableObservable#connect()}.
      * <p>
      * <em>Note:</em> You sacrifice the ability to unsubscribe from the origin when you use the {@code cache}
      * Observer so be careful not to use this Observer on Observables that emit an infinite or very large number
-     * of items that will use up memory. 
+     * of items that will use up memory.
      * A possible workaround is to apply `takeUntil` with a predicate or
      * another source before (and perhaps after) the application of cache().
      * <pre><code>
      * AtomicBoolean shouldStop = new AtomicBoolean();
-     * 
+     *
      * source.takeUntil(v -&gt; shouldStop.get())
      *       .cache()
      *       .takeUntil(v -&gt; shouldStop.get())
@@ -4983,10 +4983,10 @@ public final <B> Observable<List<T>> buffer(Observable<B> boundary, int initialC
      * </code></pre>
      * Since the operator doesn't allow clearing the cached values either, the possible workaround is
      * to forget all references to it via {@link #onTerminateDetach()} applied along with the previous
-     * workaround: 
+     * workaround:
      * <pre><code>
      * AtomicBoolean shouldStop = new AtomicBoolean();
-     * 
+     *
      * source.takeUntil(v -&gt; shouldStop.get())
      *       .onTerminateDetach()
      *       .cache()
@@ -5001,7 +5001,7 @@ public final <B> Observable<List<T>> buffer(Observable<B> boundary, int initialC
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code cache} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that, when first subscribed to, caches all of its items and notifications for the
      *         benefit of subsequent subscribers
      * @see <a href="http://reactivex.io/documentation/operators/replay.html">ReactiveX operators documentation: Replay</a>
@@ -5024,7 +5024,7 @@ public final Observable<T> cache(int initialCapacity) {
     }
 
     /**
-     * Returns an Observable that subscribes to this Observable lazily, caches all of its events 
+     * Returns an Observable that subscribes to this Observable lazily, caches all of its events
      * and replays them, in the same order as received, to all the downstream subscribers.
      * <p>
      * <img width="640" height="410" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/cache.png" alt="">
@@ -5034,7 +5034,7 @@ public final Observable<T> cache(int initialCapacity) {
      * <p>
      * The operator subscribes only when the first downstream subscriber subscribes and maintains
      * a single subscription towards this Observable. In contrast, the operator family of {@link #replay()}
-     * that return a {@link ConnectableObservable} require an explicit call to {@link ConnectableObservable#connect()}.  
+     * that return a {@link ConnectableObservable} require an explicit call to {@link ConnectableObservable#connect()}.
      * <p>
      * <em>Note:</em> You sacrifice the ability to unsubscribe from the origin when you use the {@code cache}
      * Observer so be careful not to use this Observer on Observables that emit an infinite or very large number
@@ -5043,7 +5043,7 @@ public final Observable<T> cache(int initialCapacity) {
      * another source before (and perhaps after) the application of cache().
      * <pre><code>
      * AtomicBoolean shouldStop = new AtomicBoolean();
-     * 
+     *
      * source.takeUntil(v -&gt; shouldStop.get())
      *       .cache()
      *       .takeUntil(v -&gt; shouldStop.get())
@@ -5051,10 +5051,10 @@ public final Observable<T> cache(int initialCapacity) {
      * </code></pre>
      * Since the operator doesn't allow clearing the cached values either, the possible workaround is
      * to forget all references to it via {@link #onTerminateDetach()} applied along with the previous
-     * workaround: 
+     * workaround:
      * <pre><code>
      * AtomicBoolean shouldStop = new AtomicBoolean();
-     * 
+     *
      * source.takeUntil(v -&gt; shouldStop.get())
      *       .onTerminateDetach()
      *       .cache()
@@ -5072,7 +5072,7 @@ public final Observable<T> cache(int initialCapacity) {
      * <p>
      * <em>Note:</em> The capacity hint is not an upper bound on cache size. For that, consider
      * {@link #replay(int)} in combination with {@link ConnectableObservable#autoConnect()} or similar.
-     * 
+     *
      * @param initialCapacity hint for number of items to cache (for optimizing underlying data structure)
      * @return an Observable that, when first subscribed to, caches all of its items and notifications for the
      *         benefit of subsequent subscribers
@@ -5094,7 +5094,7 @@ public final Observable<T> cacheWithInitialCapacity(int initialCapacity) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code cast} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the output value type cast to
      * @param klass
      *            the target class type that {@code cast} will cast the items emitted by the source Observable
@@ -5121,7 +5121,7 @@ public final <R> Observable<R> cast(final Class<R> klass) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code collect} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the accumulator and output type
      * @param stateFactory
      *           the mutable data structure that will collect the items
@@ -5136,7 +5136,7 @@ public final <R> Observable<R> collect(Func0<R> stateFactory, final Action2<R, ?
         /*
          * Discussion and confirmation of implementation at
          * https://github.com/ReactiveX/RxJava/issues/423#issuecomment-27642532
-         * 
+         *
          * It should use last() not takeLast(1) since it needs to emit an error if the sequence is empty.
          */
         return create(new OnSubscribeCollect<T, R>(this, stateFactory, collector));
@@ -5153,12 +5153,12 @@ public final <R> Observable<R> collect(Func0<R> stateFactory, final Action2<R, ?
      *  <dd>The operator honors backpressure from downstream. Both this and the inner {@code Observable}s are
      *  expected to honor backpressure as well. If the source {@code Observable} violates the rule, the operator will
      *  signal a {@code MissingBackpressureException}. If any of the inner {@code Observable}s doesn't honor
-     *  backpressure, that <em>may</em> throw an {@code IllegalStateException} when that 
+     *  backpressure, that <em>may</em> throw an {@code IllegalStateException} when that
      *  {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the type of the inner Observable sources and thus the ouput type
      * @param func
      *            a function that, when applied to an item emitted by the source Observable, returns an
@@ -5174,24 +5174,24 @@ public final <R> Observable<R> concatMap(Func1<? super T, ? extends Observable<?
         }
         return create(new OnSubscribeConcatMap<T, R>(this, func, 2, OnSubscribeConcatMap.IMMEDIATE));
     }
-    
+
     /**
      * Maps each of the items into an Observable, subscribes to them one after the other,
      * one at a time and emits their values in order
      * while delaying any error from either this or any of the inner Observables
      * till all of them terminate.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. Both this and the inner {@code Observable}s are
      *  expected to honor backpressure as well. If the source {@code Observable} violates the rule, the operator will
      *  signal a {@code MissingBackpressureException}. If any of the inner {@code Observable}s doesn't honor
-     *  backpressure, that <em>may</em> throw an {@code IllegalStateException} when that 
+     *  backpressure, that <em>may</em> throw an {@code IllegalStateException} when that
      *  {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concatMapDelayError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the result value type
      * @param func the function that maps the items of this Observable into the inner Observables.
      * @return the new Observable instance with the concatenation behavior
@@ -5204,12 +5204,12 @@ public final <R> Observable<R> concatMapDelayError(Func1<? super T, ? extends Ob
         }
         return create(new OnSubscribeConcatMap<T, R>(this, func, 2, OnSubscribeConcatMap.END));
     }
-    
+
     /**
      * Returns an Observable that concatenate each item emitted by the source Observable with the values in an
      * Iterable corresponding to that item that is generated by a selector.
      * <p>
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s is
@@ -5218,7 +5218,7 @@ public final <R> Observable<R> concatMapDelayError(Func1<? super T, ? extends Ob
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concatMapIterable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the type of item emitted by the resulting Observable
      * @param collectionSelector
@@ -5231,7 +5231,7 @@ public final <R> Observable<R> concatMapDelayError(Func1<? super T, ? extends Ob
     public final <R> Observable<R> concatMapIterable(Func1<? super T, ? extends Iterable<? extends R>> collectionSelector) {
         return OnSubscribeFlattenIterable.createFrom(this, collectionSelector, RxRingBuffer.SIZE);
     }
-    
+
     /**
      * Returns an Observable that emits the items emitted from the current Observable, then the next, one after
      * the other, without interleaving them.
@@ -5245,7 +5245,7 @@ public final <R> Observable<R> concatMapIterable(Func1<? super T, ? extends Iter
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            an Observable to be concatenated after the current
      * @return an Observable that emits items emitted by the two source Observables, one after the other,
@@ -5268,7 +5268,7 @@ public final Observable<T> concatWith(Observable<? extends T> t1) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code contains} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param element
      *            the item to search for in the emissions from the source Observable
      * @return an Observable that emits {@code true} if the specified item is emitted by the source Observable,
@@ -5290,7 +5290,7 @@ public final Observable<Boolean> contains(final Object element) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code count} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits a single item: the number of elements emitted by the source Observable
      * @see <a href="http://reactivex.io/documentation/operators/count.html">ReactiveX operators documentation: Count</a>
      * @see #countLong()
@@ -5298,7 +5298,7 @@ public final Observable<Boolean> contains(final Object element) {
     public final Observable<Integer> count() {
         return reduce(0, InternalObservableUtils.COUNTER);
     }
-    
+
     /**
      * Returns an Observable that counts the total number of items emitted by the source Observable and emits
      * this count as a 64-bit Long.
@@ -5311,7 +5311,7 @@ public final Observable<Integer> count() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code countLong} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits a single item: the number of items emitted by the source Observable as a
      *         64-bit Long item
      * @see <a href="http://reactivex.io/documentation/operators/count.html">ReactiveX operators documentation: Count</a>
@@ -5333,7 +5333,7 @@ public final Observable<Long> countLong() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code debounce} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U>
      *            the debounce value type (ignored)
      * @param debounceSelector
@@ -5370,7 +5370,7 @@ public final <U> Observable<T> debounce(Func1<? super T, ? extends Observable<U>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code debounce} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            the time each item has to be "the most recent" of those emitted by the source Observable to
      *            ensure that it's not dropped
@@ -5409,7 +5409,7 @@ public final Observable<T> debounce(long timeout, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            the time each item has to be "the most recent" of those emitted by the source Observable to
      *            ensure that it's not dropped
@@ -5437,12 +5437,12 @@ public final Observable<T> debounce(long timeout, TimeUnit unit, Scheduler sched
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>If the source {@code Observable} is empty, this operator is guaranteed to honor backpressure from downstream.
      *  If the source {@code Observable} is non-empty, it is expected to honor backpressure as well; if the rule is violated,
-     *  a {@code MissingBackpressureException} <em>may</em> get signalled somewhere downstream. 
+     *  a {@code MissingBackpressureException} <em>may</em> get signalled somewhere downstream.
      *  </dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code defaultIfEmpty} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param defaultValue
      *            the item to emit if the source Observable emits no items
      * @return an Observable that emits either the specified default item if the source Observable emits no
@@ -5462,7 +5462,7 @@ public final Observable<T> defaultIfEmpty(final T defaultValue) {
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>If the source {@code Observable} is empty, the alternate {@code Observable} is expected to honor backpressure.
      *  If the source {@code Observable} is non-empty, it is expected to honor backpressure as instead.
-     *  In either case, if violated, a {@code MissingBackpressureException} <em>may</em> get 
+     *  In either case, if violated, a {@code MissingBackpressureException} <em>may</em> get
      *  signalled somewhere downstream.
      *  </dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -5489,13 +5489,13 @@ public final Observable<T> switchIfEmpty(Observable<? extends T> alternate) {
      * from the source Observable.
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}. 
+     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}.
      *  All of the other {@code Observable}s supplied by the functions are consumed
      *  in an unbounded manner (i.e., no backpressure applied to them).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code delay} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U>
      *            the subscription delay value type (ignored)
      * @param <V>
@@ -5527,13 +5527,13 @@ public final <U, V> Observable<T> delay(
      * from the source Observable.
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}. 
+     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}.
      *  All of the other {@code Observable}s supplied by the function are consumed
      *  in an unbounded manner (i.e., no backpressure applied to them).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code delay} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U>
      *            the item delay value type (ignored)
      * @param itemDelay
@@ -5559,7 +5559,7 @@ public final <U> Observable<T> delay(Func1<? super T, ? extends Observable<U>> i
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code delay} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param delay
      *            the delay to shift the source by
      * @param unit
@@ -5582,7 +5582,7 @@ public final Observable<T> delay(long delay, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param delay
      *            the delay to shift the source by
      * @param unit
@@ -5606,7 +5606,7 @@ public final Observable<T> delay(long delay, TimeUnit unit, Scheduler scheduler)
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code delay} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param delay
      *            the time to delay the subscription
      * @param unit
@@ -5629,7 +5629,7 @@ public final Observable<T> delaySubscription(long delay, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param delay
      *            the time to delay the subscription
      * @param unit
@@ -5643,7 +5643,7 @@ public final Observable<T> delaySubscription(long delay, TimeUnit unit) {
     public final Observable<T> delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) {
         return create(new OnSubscribeDelaySubscription<T>(this, delay, unit, scheduler));
     }
-    
+
     /**
      * Returns an Observable that delays the subscription to the source Observable until a second Observable
      * emits an item.
@@ -5651,13 +5651,13 @@ public final Observable<T> delaySubscription(long delay, TimeUnit unit, Schedule
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/delaySubscription.o.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}. 
-     *  The other {@code Observable}s supplied by the function is consumed in an unbounded manner 
+     *  <dd>The operator doesn't interfere with the backpressure behavior which is determined by the source {@code Observable}.
+     *  The other {@code Observable}s supplied by the function is consumed in an unbounded manner
      *  (i.e., no backpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This method does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U> the element type of the delaying Observable
      * @param subscriptionDelay
      *            a function that returns an Observable that triggers the subscription to the source Observable
@@ -5681,7 +5681,7 @@ public final <U> Observable<T> delaySubscription(Func0<? extends Observable<U>>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This method does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U> the value type of the other Observable, irrelevant
      * @param other the other Observable that should trigger the subscription
      *        to this Observable.
@@ -5695,7 +5695,7 @@ public final <U> Observable<T> delaySubscription(Observable<U> other) {
         }
         return create(new OnSubscribeDelaySubscriptionOther<T, U>(this, other));
     }
-    
+
     /**
      * Returns an Observable that reverses the effect of {@link #materialize materialize} by transforming the
      * {@link Notification} objects emitted by the source Observable into the items or notifications they
@@ -5733,7 +5733,7 @@ public final <T2> Observable<T2> dematerialize() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code distinct} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits only those items emitted by the source Observable that are distinct from
      *         each other
      * @see <a href="http://reactivex.io/documentation/operators/distinct.html">ReactiveX operators documentation: Distinct</a>
@@ -5754,7 +5754,7 @@ public final Observable<T> distinct() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code distinct} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U> the key type
      * @param keySelector
      *            a function that projects an emitted item to a key value that is used to decide whether an item
@@ -5778,7 +5778,7 @@ public final <U> Observable<T> distinct(Func1<? super T, ? extends U> keySelecto
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits those items from the source Observable that are distinct from their
      *         immediate predecessors
      * @see <a href="http://reactivex.io/documentation/operators/distinct.html">ReactiveX operators documentation: Distinct</a>
@@ -5799,7 +5799,7 @@ public final Observable<T> distinctUntilChanged() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code distinctUntilChanged} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U> the key type
      * @param keySelector
      *            a function that projects an emitted item to a key value that is used to decide whether an item
@@ -5849,7 +5849,7 @@ public final Observable<T> distinctUntilChanged(Func2<? super T, ? super T, Bool
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnCompleted} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onCompleted
      *            the action to invoke when the source Observable calls {@code onCompleted}
      * @return the source Observable with the side-effecting behavior applied
@@ -5874,7 +5874,7 @@ public final Observable<T> doOnCompleted(final Action0 onCompleted) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnEach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onNotification
      *            the action to invoke for each item emitted by the source Observable
      * @return the source Observable with the side-effecting behavior applied
@@ -5901,7 +5901,7 @@ public final Observable<T> doOnEach(final Action1<Notification<? super T>> onNot
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnEach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param observer
      *            the observer to be notified about onNext, onError and onCompleted events on its
      *            respective methods before the actual downstream Subscriber gets notified.
@@ -5926,7 +5926,7 @@ public final Observable<T> doOnEach(Observer<? super T> observer) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnError} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onError
      *            the action to invoke if the source Observable calls {@code onError}
      * @return the source Observable with the side-effecting behavior applied
@@ -5951,7 +5951,7 @@ public final Observable<T> doOnError(final Action1<Throwable> onError) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onNext
      *            the action to invoke when the source Observable calls {@code onNext}
      * @return the source Observable with the side-effecting behavior applied
@@ -6016,7 +6016,7 @@ public final Observable<T> doOnRequest(final Action1<Long> onRequest) {
     public final Observable<T> doOnSubscribe(final Action0 subscribe) {
         return lift(new OperatorDoOnSubscribe<T>(subscribe));
     }
-    
+
     /**
      * Modifies the source Observable so that it invokes an action when it calls {@code onCompleted} or
      * {@code onError}.
@@ -6032,7 +6032,7 @@ public final Observable<T> doOnSubscribe(final Action0 subscribe) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code doOnTerminate} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onTerminate
      *            the action to invoke when the source Observable calls {@code onCompleted} or {@code onError}
      * @return the source Observable with the side-effecting behavior applied
@@ -6042,12 +6042,12 @@ public final Observable<T> doOnSubscribe(final Action0 subscribe) {
     public final Observable<T> doOnTerminate(final Action0 onTerminate) {
         Action1<T> onNext = Actions.empty();
         Action1<Throwable> onError = Actions.toAction1(onTerminate);
-        
+
         Observer<T> observer = new ActionObserver<T>(onNext, onError, onTerminate);
 
         return create(new OnSubscribeDoOnEach<T>(this, observer));
     }
-    
+
     /**
      * Calls the unsubscribe {@code Action0} if the downstream unsubscribes the sequence.
      * <p>
@@ -6090,7 +6090,7 @@ public final Observable<T> doOnUnsubscribe(final Action0 unsubscribe) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This method does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * @param <T> the value type 
+     * @param <T> the value type
      * @param o1 the first source
      * @param o2 the second source
      * @return the new Observable instance with the specified concatenation behavior
@@ -6101,7 +6101,7 @@ public final Observable<T> doOnUnsubscribe(final Action0 unsubscribe) {
     public static <T> Observable<T> concatEager(Observable<? extends T> o1, Observable<? extends T> o2) {
         return concatEager(Arrays.asList(o1, o2));
     }
-    
+
     /**
      * Concatenates three sources eagerly into a single stream of values.
      * <p>
@@ -6130,7 +6130,7 @@ public static <T> Observable<T> concatEager(
         ) {
         return concatEager(Arrays.asList(o1, o2, o3));
     }
-    
+
     /**
      * Concatenates four sources eagerly into a single stream of values.
      * <p>
@@ -6160,7 +6160,7 @@ public static <T> Observable<T> concatEager(
         ) {
         return concatEager(Arrays.asList(o1, o2, o3, o4));
     }
-    
+
     /**
      * Concatenates five sources eagerly into a single stream of values.
      * <p>
@@ -6260,7 +6260,7 @@ public static <T> Observable<T> concatEager(
         ) {
         return concatEager(Arrays.asList(o1, o2, o3, o4, o5, o6, o7));
     }
-    
+
     /**
      * Concatenates eight sources eagerly into a single stream of values.
      * <p>
@@ -6383,7 +6383,7 @@ public static <T> Observable<T> concatEager(Iterable<? extends Observable<? exte
     public static <T> Observable<T> concatEager(Iterable<? extends Observable<? extends T>> sources, int capacityHint) {
         return Observable.from(sources).concatMapEager((Func1)UtilityFunctions.identity(), capacityHint);
     }
-    
+
     /**
      * Concatenates an Observable sequence of Observables eagerly into a single stream of values.
      * <p>
@@ -6432,7 +6432,7 @@ public static <T> Observable<T> concatEager(Observable<? extends Observable<? ex
     public static <T> Observable<T> concatEager(Observable<? extends Observable<? extends T>> sources, int capacityHint) {
         return sources.concatMapEager((Func1)UtilityFunctions.identity(), capacityHint);
     }
-    
+
     /**
      * Maps a sequence of values into Observables and concatenates these Observables eagerly into a single
      * Observable.
@@ -6519,7 +6519,7 @@ public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observa
         }
         return lift(new OperatorEagerConcatMap<T, R>(mapper, capacityHint, maxConcurrent));
     }
-    
+
     /**
      * Returns an Observable that emits the single item at a specified index in a sequence of emissions from a
      * source Observable.
@@ -6532,7 +6532,7 @@ public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observa
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code elementAt} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param index
      *            the zero-based index of the item to retrieve
      * @return an Observable that emits a single item: the item at the specified position in the sequence of
@@ -6559,7 +6559,7 @@ public final Observable<T> elementAt(int index) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code elementAtOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param index
      *            the zero-based index of the item to retrieve
      * @param defaultValue
@@ -6590,7 +6590,7 @@ public final Observable<T> elementAtOrDefault(int index, T defaultValue) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code exists} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param predicate
      *            the condition to test items emitted by the source Observable
      * @return an Observable that emits a Boolean that indicates whether any item emitted by the source
@@ -6612,7 +6612,7 @@ public final Observable<Boolean> exists(Func1<? super T, Boolean> predicate) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code filter} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param predicate
      *            a function that evaluates each item emitted by the source Observable, returning {@code true}
      *            if it passes the filter
@@ -6636,7 +6636,7 @@ public final Observable<T> filter(Func1<? super T, Boolean> predicate) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code finallyDo} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param action
      *            an {@link Action0} to be invoked when the source Observable finishes
      * @return an Observable that emits the same items as the source Observable, then invokes the
@@ -6686,7 +6686,7 @@ public final Observable<T> doAfterTerminate(Action0 action) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code first} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits only the very first item emitted by the source Observable, or raises an
      *         {@code NoSuchElementException} if the source Observable is empty
      * @see <a href="http://reactivex.io/documentation/operators/first.html">ReactiveX operators documentation: First</a>
@@ -6707,7 +6707,7 @@ public final Observable<T> first() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code first} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param predicate
      *            the condition that an item emitted by the source Observable has to satisfy
      * @return an Observable that emits only the very first item emitted by the source Observable that satisfies
@@ -6730,7 +6730,7 @@ public final Observable<T> first(Func1<? super T, Boolean> predicate) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code firstOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param defaultValue
      *            the default item to emit if the source Observable doesn't emit anything
      * @return an Observable that emits only the very first item from the source, or a default item if the
@@ -6753,7 +6753,7 @@ public final Observable<T> firstOrDefault(T defaultValue) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code firstOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param predicate
      *            the condition any item emitted by the source Observable has to satisfy
      * @param defaultValue
@@ -6781,7 +6781,7 @@ public final Observable<T> firstOrDefault(T defaultValue, Func1<? super T, Boole
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the value type of the inner Observables and the output type
      * @param func
      *            a function that, when applied to an item emitted by the source Observable, returns an
@@ -6812,7 +6812,7 @@ public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the value type of the inner Observables and the output type
      * @param func
      *            a function that, when applied to an item emitted by the source Observable, returns an
@@ -6846,7 +6846,7 @@ public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? e
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the result type
      * @param onNext
@@ -6869,7 +6869,7 @@ public final <R> Observable<R> flatMap(
     }
     /**
      * Returns an Observable that applies a function to each item emitted or notification raised by the source
-     * Observable and then flattens the Observables returned from these functions and emits the resulting items, 
+     * Observable and then flattens the Observables returned from these functions and emits the resulting items,
      * while limiting the maximum number of concurrent subscriptions to these Observables.
      * <p>
      * <!-- <img width="640" height="410" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/mergeMap.nce.png" alt=""> -->
@@ -6880,7 +6880,7 @@ public final <R> Observable<R> flatMap(
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the result type
      * @param onNext
@@ -6918,7 +6918,7 @@ public final <R> Observable<R> flatMap(
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U>
      *            the type of items emitted by the collection Observable
      * @param <R>
@@ -6949,7 +6949,7 @@ public final <U, R> Observable<R> flatMap(final Func1<? super T, ? extends Obser
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U>
      *            the type of items emitted by the collection Observable
      * @param <R>
@@ -6985,7 +6985,7 @@ public final <U, R> Observable<R> flatMap(final Func1<? super T, ? extends Obser
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the type of item emitted by the resulting Observable
      * @param collectionSelector
@@ -7032,7 +7032,7 @@ public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterab
     public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterable<? extends R>> collectionSelector, int maxConcurrent) {
         return OnSubscribeFlattenIterable.createFrom(this, collectionSelector, maxConcurrent);
     }
-    
+
     /**
      * Returns an Observable that emits the results of applying a function to the pair of values from the source
      * Observable and an Iterable corresponding to that item that is generated by a selector.
@@ -7045,7 +7045,7 @@ public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterab
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapIterable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U>
      *            the collection element type
      * @param <R>
@@ -7118,7 +7118,7 @@ public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Ite
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code forEach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onNext
      *            {@link Action1} to execute for each item.
      * @throws IllegalArgumentException
@@ -7130,7 +7130,7 @@ public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Ite
     public final void forEach(final Action1<? super T> onNext) {
         subscribe(onNext);
     }
-    
+
     /**
      * Subscribes to the {@link Observable} and receives notifications for each element and error events.
      * <p>
@@ -7142,7 +7142,7 @@ public final void forEach(final Action1<? super T> onNext) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code forEach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onNext
      *            {@link Action1} to execute for each item.
      * @param onError
@@ -7157,7 +7157,7 @@ public final void forEach(final Action1<? super T> onNext) {
     public final void forEach(final Action1<? super T> onNext, final Action1<Throwable> onError) {
         subscribe(onNext, onError);
     }
-    
+
     /**
      * Subscribes to the {@link Observable} and receives notifications for each element and the terminal events.
      * <p>
@@ -7169,7 +7169,7 @@ public final void forEach(final Action1<? super T> onNext, final Action1<Throwab
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code forEach} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onNext
      *            {@link Action1} to execute for each item.
      * @param onError
@@ -7187,12 +7187,12 @@ public final void forEach(final Action1<? super T> onNext, final Action1<Throwab
     public final void forEach(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onComplete) {
         subscribe(onNext, onError, onComplete);
     }
-    
+
     /**
      * Groups the items emitted by an {@code Observable} according to a specified criterion, and emits these
-     * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservable} allows only a single 
-     * {@link Subscriber} during its lifetime and if this {@code Subscriber} unsubscribes before the 
-     * source terminates, the next emission by the source having the same key will trigger a new 
+     * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservable} allows only a single
+     * {@link Subscriber} during its lifetime and if this {@code Subscriber} unsubscribes before the
+     * source terminates, the next emission by the source having the same key will trigger a new
      * {@code GroupedObservable} emission.
      * <p>
      * <img width="640" height="360" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/groupBy.png" alt="">
@@ -7211,7 +7211,7 @@ public final void forEach(final Action1<? super T> onNext, final Action1<Throwab
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code groupBy} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param keySelector
      *            a function that extracts the key for each item
      * @param elementSelector
@@ -7228,12 +7228,12 @@ public final void forEach(final Action1<? super T> onNext, final Action1<Throwab
     public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? super T, ? extends K> keySelector, final Func1<? super T, ? extends R> elementSelector) {
         return lift(new OperatorGroupBy<T, K, R>(keySelector, elementSelector));
     }
-    
+
     /**
      * Groups the items emitted by an {@code Observable} according to a specified criterion, and emits these
-     * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservable} allows only a single 
-     * {@link Subscriber} during its lifetime and if this {@code Subscriber} unsubscribes before the 
-     * source terminates, the next emission by the source having the same key will trigger a new 
+     * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservable} allows only a single
+     * {@link Subscriber} during its lifetime and if this {@code Subscriber} unsubscribes before the
+     * source terminates, the next emission by the source having the same key will trigger a new
      * {@code GroupedObservable} emission.
      * <p>
      * <img width="640" height="360" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/groupBy.png" alt="">
@@ -7252,20 +7252,20 @@ public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? su
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code groupBy} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param keySelector
      *            a function that extracts the key for each item
      * @param elementSelector
      *            a function that extracts the return element for each item
      * @param evictingMapFactory
-     *            a function that given an eviction action returns a {@link Map} instance that will be used to assign 
-     *            items to the appropriate {@code GroupedObservable}s. The {@code Map} instance must be thread-safe 
-     *            and any eviction must trigger a call to the supplied action (synchronously or asynchronously). 
-     *            This can be used to limit the size of the map by evicting keys by maximum size or access time for 
+     *            a function that given an eviction action returns a {@link Map} instance that will be used to assign
+     *            items to the appropriate {@code GroupedObservable}s. The {@code Map} instance must be thread-safe
+     *            and any eviction must trigger a call to the supplied action (synchronously or asynchronously).
+     *            This can be used to limit the size of the map by evicting keys by maximum size or access time for
      *            instance. Here's an example using Guava's {@code CacheBuilder} from v19.0:
      *            <pre>
      *            {@code
-     *            Func1<Action1<K>, Map<K, Object>> mapFactory 
+     *            Func1<Action1<K>, Map<K, Object>> mapFactory
      *              = action -> CacheBuilder.newBuilder()
      *                  .maximumSize(1000)
      *                  .expireAfterAccess(12, TimeUnit.HOURS)
@@ -7273,7 +7273,7 @@ public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? su
      *                  .<K, Object> build().asMap();
      *            }
      *            </pre>
-     *            
+     *
      * @param <K>
      *            the key type
      * @param <R>
@@ -7286,19 +7286,19 @@ public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? su
      * @see <a href="http://reactivex.io/documentation/operators/groupby.html">ReactiveX operators documentation: GroupBy</a>
      */
     @Experimental
-    public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? super T, ? extends K> keySelector, 
+    public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? super T, ? extends K> keySelector,
             final Func1<? super T, ? extends R> elementSelector, final Func1<Action1<K>, Map<K, Object>> evictingMapFactory) {
         if (evictingMapFactory == null) {
             throw new NullPointerException("evictingMapFactory cannot be null");
         }
         return lift(new OperatorGroupBy<T, K, R>(keySelector, elementSelector, evictingMapFactory));
     }
-    
+
     /**
      * Groups the items emitted by an {@code Observable} according to a specified criterion, and emits these
-     * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservable} allows only a single 
-     * {@link Subscriber} during its lifetime and if this {@code Subscriber} unsubscribes before the 
-     * source terminates, the next emission by the source having the same key will trigger a new 
+     * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservable} allows only a single
+     * {@link Subscriber} during its lifetime and if this {@code Subscriber} unsubscribes before the
+     * source terminates, the next emission by the source having the same key will trigger a new
      * {@code GroupedObservable} emission.
      * <p>
      * <img width="640" height="360" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/groupBy.png" alt="">
@@ -7317,7 +7317,7 @@ public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? su
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code groupBy} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param keySelector
      *            a function that extracts the key for each item
      * @param <K>
@@ -7345,7 +7345,7 @@ public final <K> Observable<GroupedObservable<K, T>> groupBy(final Func1<? super
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code groupJoin} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T2> the value type of the right Observable source
      * @param <D1> the element type of the left duration Observables
      * @param <D2> the element type of the right duration Observables
@@ -7382,7 +7382,7 @@ public final <T2, D1, D2, R> Observable<R> groupJoin(Observable<T2> right, Func1
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code ignoreElements} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an empty Observable that only calls {@code onCompleted} or {@code onError}, based on which one is
      *         called by the source Observable
      * @see <a href="http://reactivex.io/documentation/operators/ignoreelements.html">ReactiveX operators documentation: IgnoreElements</a>
@@ -7405,14 +7405,14 @@ public final Observable<T> ignoreElements() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code isEmpty} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits a Boolean
      * @see <a href="http://reactivex.io/documentation/operators/contains.html">ReactiveX operators documentation: Contains</a>
      */
     public final Observable<Boolean> isEmpty() {
         return lift(InternalObservableUtils.IS_EMPTY);
     }
-    
+
     /**
      * Correlates the items emitted by two Observables based on overlapping durations.
      * <p>
@@ -7427,7 +7427,7 @@ public final Observable<Boolean> isEmpty() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code join} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <TRight> the value type of the right Observable source
      * @param <TLeftDuration> the element type of the left duration Observables
      * @param <TRightDuration> the element type of the right duration Observables
@@ -7465,7 +7465,7 @@ public final <TRight, TLeftDuration, TRightDuration, R> Observable<R> join(Obser
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code last} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits the last item from the source Observable or notifies observers of an
      *         error
      * @see <a href="http://reactivex.io/documentation/operators/last.html">ReactiveX operators documentation: Last</a>
@@ -7486,7 +7486,7 @@ public final Observable<T> last() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code last} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param predicate
      *            the condition any source emitted item has to satisfy
      * @return an Observable that emits only the last item satisfying the given condition from the source, or an
@@ -7511,7 +7511,7 @@ public final Observable<T> last(Func1<? super T, Boolean> predicate) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code lastOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param defaultValue
      *            the default item to emit if the source Observable is empty
      * @return an Observable that emits only the last item emitted by the source Observable, or a default item
@@ -7534,7 +7534,7 @@ public final Observable<T> lastOrDefault(T defaultValue) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code lastOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param defaultValue
      *            the default item to emit if the source Observable doesn't emit anything that satisfies the
      *            specified {@code predicate}
@@ -7566,7 +7566,7 @@ public final Observable<T> lastOrDefault(T defaultValue, Func1<? super T, Boolea
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code limit} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum number of items to emit
      * @return an Observable that emits only the first {@code count} items emitted by the source Observable, or
@@ -7576,7 +7576,7 @@ public final Observable<T> lastOrDefault(T defaultValue, Func1<? super T, Boolea
     public final Observable<T> limit(int count) {
         return take(count);
     }
-    
+
     /**
      * Returns an Observable that applies a specified function to each item emitted by the source Observable and
      * emits the results of these function applications.
@@ -7589,7 +7589,7 @@ public final Observable<T> limit(int count) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code map} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the output type
      * @param func
      *            a function to apply to each item emitted by the Observable
@@ -7600,7 +7600,7 @@ public final Observable<T> limit(int count) {
     public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
         return create(new OnSubscribeMap<T, R>(this, func));
     }
-    
+
     private <R> Observable<R> mapNotification(Func1<? super T, ? extends R> onNext, Func1<? super Throwable, ? extends R> onError, Func0<? extends R> onCompleted) {
         return lift(new OperatorMapNotification<T, R>(onNext, onError, onCompleted));
     }
@@ -7617,7 +7617,7 @@ private <R> Observable<R> mapNotification(Func1<? super T, ? extends R> onNext,
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code materialize} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits items that are the result of materializing the items and notifications
      *         of the source Observable
      * @see <a href="http://reactivex.io/documentation/operators/materialize-dematerialize.html">ReactiveX operators documentation: Materialize</a>
@@ -7640,7 +7640,7 @@ public final Observable<Notification<T>> materialize() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code mergeWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            an Observable to be merged
      * @return an Observable that emits all of the items emitted by the source Observables
@@ -7649,7 +7649,7 @@ public final Observable<Notification<T>> materialize() {
     public final Observable<T> mergeWith(Observable<? extends T> t1) {
         return merge(this, t1);
     }
-    
+
     /**
      * Modifies an Observable to perform its emissions and notifications on a specified {@link Scheduler},
      * asynchronously with a bounded buffer of {@link rx.internal.util.RxRingBuffer#SIZE} slots.
@@ -7662,13 +7662,13 @@ public final Observable<T> mergeWith(Observable<? extends T> t1) {
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator honors backpressure from downstream and expects it from the source {@code Observable}. Violating this
      *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
-     *  pops up; look for sources up the chain that don't support backpressure, 
+     *  pops up; look for sources up the chain that don't support backpressure,
      *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
      *  of the {@code onBackpressureXXX} operators <strong>before</strong> applying {@code observeOn} itself.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param scheduler
      *            the {@link Scheduler} to notify {@link Observer}s on
      * @return the source Observable modified so that its {@link Observer}s are notified on the specified
@@ -7696,7 +7696,7 @@ public final Observable<T> observeOn(Scheduler scheduler) {
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator honors backpressure from downstream and expects it from the source {@code Observable}. Violating this
      *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
-     *  pops up; look for sources up the chain that don't support backpressure, 
+     *  pops up; look for sources up the chain that don't support backpressure,
      *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
      *  of the {@code onBackpressureXXX} opertors <strong>before</strong> applying {@code observeOn} itself.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -7727,13 +7727,13 @@ public final Observable<T> observeOn(Scheduler scheduler, int bufferSize) {
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator honors backpressure from downstream and expects it from the source {@code Observable}. Violating this
      *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
-     *  pops up; look for sources up the chain that don't support backpressure, 
+     *  pops up; look for sources up the chain that don't support backpressure,
      *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
      *  of the {@code onBackpressureXXX} opertors <strong>before</strong> applying {@code observeOn} itself.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param scheduler
      *            the {@link Scheduler} to notify {@link Observer}s on
      * @param delayError
@@ -7762,7 +7762,7 @@ public final Observable<T> observeOn(Scheduler scheduler, boolean delayError) {
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator honors backpressure from downstream and expects it from the source {@code Observable}. Violating this
      *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
-     *  pops up; look for sources up the chain that don't support backpressure, 
+     *  pops up; look for sources up the chain that don't support backpressure,
      *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
      *  of the {@code onBackpressureXXX} opertors <strong>before</strong> applying {@code observeOn} itself.</dd>
      *  <dt><b>Scheduler:</b></dt>
@@ -7803,7 +7803,7 @@ public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, in
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code ofType} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the output type
      * @param klass
      *            the class type to filter the items emitted by the source Observable
@@ -7940,7 +7940,7 @@ public final Observable<T> onBackpressureBuffer(long capacity, Action0 onOverflo
      * @param onDrop the action to invoke for each item dropped. onDrop action should be fast and should never block.
      * @return the source Observable modified to drop {@code onNext} notifications on overflow
      * @see <a href="http://reactivex.io/documentation/operators/backpressure.html">ReactiveX operators documentation: backpressure operators</a>
-     * @Experimental The behavior of this can change at any time. 
+     * @Experimental The behavior of this can change at any time.
      * @since 1.1.0
      */
     public final Observable<T> onBackpressureDrop(Action1<? super T> onDrop) {
@@ -7962,16 +7962,16 @@ public final Observable<T> onBackpressureDrop(Action1<? super T> onDrop) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onBackpressureDrop} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return the source Observable modified to drop {@code onNext} notifications on overflow
      * @see <a href="http://reactivex.io/documentation/operators/backpressure.html">ReactiveX operators documentation: backpressure operators</a>
      */
     public final Observable<T> onBackpressureDrop() {
         return lift(OperatorOnBackpressureDrop.<T>instance());
     }
-    
+
     /**
-     * Instructs an Observable that is emitting items faster than its observer can consume them to 
+     * Instructs an Observable that is emitting items faster than its observer can consume them to
      * hold onto the latest value and emit that on request.
      * <p>
      * <img width="640" height="245" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/bp.obp.latest.png" alt="">
@@ -7999,7 +7999,7 @@ public final Observable<T> onBackpressureDrop() {
     public final Observable<T> onBackpressureLatest() {
         return lift(OperatorOnBackpressureLatest.<T>instance());
     }
-    
+
     /**
      * Instructs an Observable to pass control to another Observable rather than invoking
      * {@link Observer#onError onError} if it encounters an error.
@@ -8021,14 +8021,14 @@ public final Observable<T> onBackpressureLatest() {
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. This and the resuming {@code Observable}s
-     *  are expected to honor backpressure as well. 
-     *  If any of them violate this expectation, the operator <em>may</em> throw an 
+     *  are expected to honor backpressure as well.
+     *  If any of them violate this expectation, the operator <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes or
      *  a {@code MissingBackpressureException} is signalled somewhere downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param resumeFunction
      *            a function that returns an Observable that will take over if the source Observable encounters
      *            an error
@@ -8060,14 +8060,14 @@ public final Observable<T> onErrorResumeNext(final Func1<? super Throwable, ? ex
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. This and the resuming {@code Observable}s
-     *  are expected to honor backpressure as well. 
+     *  are expected to honor backpressure as well.
      *  If any of them violate this expectation, the operator <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes or
      *  {@code MissingBackpressureException} is signalled somewhere downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param resumeSequence
      *            a function that returns an Observable that will take over if the source Observable encounters
      *            an error
@@ -8096,14 +8096,14 @@ public final Observable<T> onErrorResumeNext(final Observable<? extends T> resum
      * encountered.
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s is expected to honor 
-     *  backpressure as well. If it this expectation is violated, the operator <em>may</em> throw 
+     *  <dd>The operator honors backpressure from downstream. The source {@code Observable}s is expected to honor
+     *  backpressure as well. If it this expectation is violated, the operator <em>may</em> throw
      *  {@code IllegalStateException} when the source {@code Observable} completes or
      *  {@code MissingBackpressureException} is signalled somewhere downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onErrorReturn} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param resumeFunction
      *            a function that returns an item that the new Observable will emit if the source Observable
      *            encounters an error
@@ -8139,14 +8139,14 @@ public final Observable<T> onErrorReturn(Func1<? super Throwable, ? extends T> r
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. This and the resuming {@code Observable}s
-     *  are expected to honor backpressure as well. 
-     *  If any of them violate this expectation, the operator <em>may</em> throw an 
+     *  are expected to honor backpressure as well.
+     *  If any of them violate this expectation, the operator <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes or
      *  {@code MissingBackpressureException} is signalled somewhere downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code onExceptionResumeNext} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param resumeSequence
      *            a function that returns an Observable that will take over if the source Observable encounters
      *            an exception
@@ -8158,7 +8158,7 @@ public final Observable<T> onExceptionResumeNext(final Observable<? extends T> r
         return lift((Operator<T, T>)OperatorOnErrorResumeNextViaFunction.withException(resumeSequence));
     }
 
-    
+
     /**
      * Nulls out references to the upstream producer and downstream Subscriber if
      * the sequence is terminated or downstream unsubscribes.
@@ -8177,7 +8177,7 @@ public final Observable<T> onExceptionResumeNext(final Observable<? extends T> r
     public final Observable<T> onTerminateDetach() {
         return create(new OnSubscribeDetach<T>(this));
     }
-    
+
     /**
      * Returns a {@link ConnectableObservable}, which is a variety of Observable that waits until its
      * {@link ConnectableObservable#connect connect} method is called before it begins emitting items to those
@@ -8192,7 +8192,7 @@ public final Observable<T> onTerminateDetach() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code publish} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return a {@link ConnectableObservable} that upon connection causes the source Observable to emit items
      *         to its {@link Observer}s
      * @see <a href="http://reactivex.io/documentation/operators/publish.html">ReactiveX operators documentation: Publish</a>
@@ -8216,7 +8216,7 @@ public final ConnectableObservable<T> publish() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code publish} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the type of items emitted by the resulting Observable
      * @param selector
@@ -8233,17 +8233,17 @@ public final <R> Observable<R> publish(Func1<? super Observable<T>, ? extends Ob
     /**
      * Requests {@code n} initially from the upstream and then 75% of {@code n} subsequently
      * after 75% of {@code n} values have been emitted to the downstream.
-     * 
+     *
      * <p>This operator allows preventing the downstream to trigger unbounded mode via {@code request(Long.MAX_VALUE)}
      * or compensate for the per-item overhead of small and frequent requests.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator expects backpressure from upstream and honors backpressure from downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code rebatchRequests} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     *  
+     *
      * @param n the initial request amount, further request will happen after 75% of this value
      * @return the Observable that rebatches request amounts from downstream
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
@@ -8255,7 +8255,7 @@ public final Observable<T> rebatchRequests(int n) {
         }
         return lift(OperatorObserveOn.<T>rebatch(n));
     }
-    
+
     /**
      * Returns an Observable that applies a specified accumulator function to the first item emitted by a source
      * Observable, then feeds the result of that function along with the second item emitted by the source
@@ -8274,7 +8274,7 @@ public final Observable<T> rebatchRequests(int n) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code reduce} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param accumulator
      *            an accumulator function to be invoked on each item emitted by the source Observable, whose
      *            result will be used in the next accumulator call
@@ -8289,7 +8289,7 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
         /*
          * Discussion and confirmation of implementation at
          * https://github.com/ReactiveX/RxJava/issues/423#issuecomment-27642532
-         * 
+         *
          * It should use last() not takeLast(1) since it needs to emit an error if the sequence is empty.
          */
         return create(new OnSubscribeReduce<T>(this, accumulator));
@@ -8313,9 +8313,9 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
      * <pre><code>
      * Observable&lt;T> source = ...
      * Observable.defer(() -> source.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)));
-     * 
+     *
      * // alternatively, by using compose to stay fluent
-     * 
+     *
      * source.compose(o ->
      *     Observable.defer(() -> o.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)))
      * );
@@ -8327,7 +8327,7 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code reduce} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the accumulator and output value type
      * @param initialValue
      *            the initial (seed) accumulator value
@@ -8342,7 +8342,7 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
     public final <R> Observable<R> reduce(R initialValue, Func2<R, ? super T, R> accumulator) {
         return create(new OnSubscribeReduceSeed<T, R>(this, initialValue, accumulator));
     }
-    
+
     /**
      * Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely.
      * <p>
@@ -8354,7 +8354,7 @@ public final <R> Observable<R> reduce(R initialValue, Func2<R, ? super T, R> acc
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code repeat} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits the items emitted by the source Observable repeatedly and in sequence
      * @see <a href="http://reactivex.io/documentation/operators/repeat.html">ReactiveX operators documentation: Repeat</a>
      */
@@ -8374,7 +8374,7 @@ public final Observable<T> repeat() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param scheduler
      *            the Scheduler to emit the items on
      * @return an Observable that emits the items emitted by the source Observable repeatedly and in sequence
@@ -8396,7 +8396,7 @@ public final Observable<T> repeat(Scheduler scheduler) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code repeat} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the number of times the source Observable items are repeated, a count of 0 will yield an empty
      *            sequence
@@ -8422,7 +8422,7 @@ public final Observable<T> repeat(final long count) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the number of times the source Observable items are repeated, a count of 0 will yield an empty
      *            sequence
@@ -8452,7 +8452,7 @@ public final Observable<T> repeat(final long count, Scheduler scheduler) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param notificationHandler
      *            receives an Observable of notifications with which a user can complete or error, aborting the repeat.
      * @param scheduler
@@ -8480,7 +8480,7 @@ public final Observable<T> repeatWhen(final Func1<? super Observable<? extends V
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code repeatWhen} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param notificationHandler
      *            receives an Observable of notifications with which a user can complete or error, aborting the repeat.
      * @return the source Observable modified with repeat logic
@@ -8505,7 +8505,7 @@ public final Observable<T> repeatWhen(final Func1<? super Observable<? extends V
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code replay} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return a {@link ConnectableObservable} that upon connection causes the source Observable to emit its
      *         items to its {@link Observer}s
      * @see <a href="http://reactivex.io/documentation/operators/replay.html">ReactiveX operators documentation: Replay</a>
@@ -8527,7 +8527,7 @@ public final ConnectableObservable<T> replay() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code replay} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the type of items emitted by the resulting Observable
      * @param selector
@@ -8555,7 +8555,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code replay} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the type of items emitted by the resulting Observable
      * @param selector
@@ -8586,7 +8586,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code replay} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the type of items emitted by the resulting Observable
      * @param selector
@@ -8622,7 +8622,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the type of items emitted by the resulting Observable
      * @param selector
@@ -8666,7 +8666,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the type of items emitted by the resulting Observable
      * @param selector
@@ -8682,7 +8682,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      * @see <a href="http://reactivex.io/documentation/operators/replay.html">ReactiveX operators documentation: Replay</a>
      */
     public final <R> Observable<R> replay(final Func1<? super Observable<T>, ? extends Observable<R>> selector, final int bufferSize, final Scheduler scheduler) {
-        return OperatorReplay.multicastSelector(InternalObservableUtils.createReplaySupplier(this, bufferSize), 
+        return OperatorReplay.multicastSelector(InternalObservableUtils.createReplaySupplier(this, bufferSize),
                 InternalObservableUtils.createReplaySelectorAndObserveOn(selector, scheduler));
     }
 
@@ -8700,7 +8700,7 @@ public final <R> Observable<R> replay(final Func1<? super Observable<T>, ? exten
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code replay} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the type of items emitted by the resulting Observable
      * @param selector
@@ -8733,7 +8733,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the type of items emitted by the resulting Observable
      * @param selector
@@ -8768,7 +8768,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param <R>
      *            the type of items emitted by the resulting Observable
      * @param selector
@@ -8783,7 +8783,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      */
     public final <R> Observable<R> replay(final Func1<? super Observable<T>, ? extends Observable<R>> selector, final Scheduler scheduler) {
         return OperatorReplay.multicastSelector(
-                InternalObservableUtils.createReplaySupplier(this), 
+                InternalObservableUtils.createReplaySupplier(this),
                 InternalObservableUtils.createReplaySelectorAndObserveOn(selector, scheduler));
     }
 
@@ -8802,7 +8802,7 @@ public final <R> Observable<R> replay(final Func1<? super Observable<T>, ? exten
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code replay} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param bufferSize
      *            the buffer size that limits the number of items that can be replayed
      * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable and
@@ -8817,7 +8817,7 @@ public final ConnectableObservable<T> replay(final int bufferSize) {
      * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and
      * replays at most {@code bufferSize} items that were emitted during a specified time window. A Connectable
      * Observable resembles an ordinary Observable, except that it does not begin emitting items when it is
-     * subscribed to, but only when its {@code connect} method is called. 
+     * subscribed to, but only when its {@code connect} method is called.
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.nt.png" alt="">
      * <dl>
@@ -8828,7 +8828,7 @@ public final ConnectableObservable<T> replay(final int bufferSize) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code replay} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param bufferSize
      *            the buffer size that limits the number of items that can be replayed
      * @param time
@@ -8859,7 +8859,7 @@ public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param bufferSize
      *            the buffer size that limits the number of items that can be replayed
      * @param time
@@ -8886,7 +8886,7 @@ public final ConnectableObservable<T> replay(final int bufferSize, final long ti
      * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and
      * replays at most {@code bufferSize} items emitted by that Observable. A Connectable Observable resembles
      * an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only
-     * when its {@code connect} method is called. 
+     * when its {@code connect} method is called.
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.ns.png" alt="">
      * <dl>
@@ -8897,7 +8897,7 @@ public final ConnectableObservable<T> replay(final int bufferSize, final long ti
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param bufferSize
      *            the buffer size that limits the number of items that can be replayed
      * @param scheduler
@@ -8914,7 +8914,7 @@ public final ConnectableObservable<T> replay(final int bufferSize, final Schedul
      * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and
      * replays all items emitted by that Observable within a specified time window. A Connectable Observable
      * resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to,
-     * but only when its {@code connect} method is called. 
+     * but only when its {@code connect} method is called.
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.t.png" alt="">
      * <dl>
@@ -8925,7 +8925,7 @@ public final ConnectableObservable<T> replay(final int bufferSize, final Schedul
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code replay} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param time
      *            the duration of the window in which the replayed items must have been emitted
      * @param unit
@@ -8942,7 +8942,7 @@ public final ConnectableObservable<T> replay(long time, TimeUnit unit) {
      * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and
      * replays all items emitted by that Observable within a specified time window. A Connectable Observable
      * resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to,
-     * but only when its {@code connect} method is called. 
+     * but only when its {@code connect} method is called.
      * <p>
      * <img width="640" height="515" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/replay.ts.png" alt="">
      * <dl>
@@ -8953,7 +8953,7 @@ public final ConnectableObservable<T> replay(long time, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param time
      *            the duration of the window in which the replayed items must have been emitted
      * @param unit
@@ -8983,7 +8983,7 @@ public final ConnectableObservable<T> replay(final long time, final TimeUnit uni
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param scheduler
      *            the Scheduler on which the Observers will observe the emitted items
      * @return a {@link ConnectableObservable} that shares a single subscription to the source Observable that
@@ -9015,7 +9015,7 @@ public final ConnectableObservable<T> replay(final Scheduler scheduler) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code retry} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return the source Observable modified with retry logic
      * @see <a href="http://reactivex.io/documentation/operators/retry.html">ReactiveX operators documentation: Retry</a>
      */
@@ -9044,7 +9044,7 @@ public final Observable<T> retry() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code retry} operates by default on the {@code trampoline} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            number of retry attempts before failing
      * @return the source Observable modified with retry logic
@@ -9084,14 +9084,14 @@ public final Observable<T> retry(Func2<Integer, Throwable, Boolean> predicate) {
      * {@link Throwable} item to the Observable provided as an argument to the {@code notificationHandler}
      * function. If that Observable calls {@code onComplete} or {@code onError} then {@code retry} will call
      * {@code onCompleted} or {@code onError} on the child subscription. Otherwise, this Observable will
-     * resubscribe to the source Observable.    
+     * resubscribe to the source Observable.
      * <p>
      * <img width="640" height="430" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/retryWhen.f.png" alt="">
-     * 
+     *
      * Example:
-     * 
+     *
      * This retries 3 times, each time incrementing the number of seconds it waits.
-     * 
+     *
      * <pre><code>
      *  Observable.create((Subscriber<? super String> s) -> {
      *      System.out.println("subscribing");
@@ -9103,7 +9103,7 @@ public final Observable<T> retry(Func2<Integer, Throwable, Boolean> predicate) {
      *      });
      *  }).toBlocking().forEach(System.out::println);
      * </code></pre>
-     * 
+     *
      * Output is:
      *
      * <pre> {@code
@@ -9139,7 +9139,7 @@ public final Observable<T> retryWhen(final Func1<? super Observable<? extends Th
      * error to the Observable returned from {@code notificationHandler}. If that Observable calls
      * {@code onComplete} or {@code onError} then {@code retry} will call {@code onCompleted} or {@code onError}
      * on the child subscription. Otherwise, this Observable will resubscribe to the source observable, on a
-     * particular Scheduler.    
+     * particular Scheduler.
      * <p>
      * <img width="640" height="430" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/retryWhen.f.png" alt="">
      * <p>
@@ -9174,7 +9174,7 @@ public final Observable<T> retryWhen(final Func1<? super Observable<? extends Th
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code sample} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param period
      *            the sampling rate
      * @param unit
@@ -9200,7 +9200,7 @@ public final Observable<T> sample(long period, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param period
      *            the sampling rate
      * @param unit
@@ -9230,7 +9230,7 @@ public final Observable<T> sample(long period, TimeUnit unit, Scheduler schedule
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code sample} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U> the element type of the sampler Observable
      * @param sampler
      *            the Observable to use for sampling the source Observable
@@ -9259,7 +9259,7 @@ public final <U> Observable<T> sample(Observable<U> sampler) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code scan} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param accumulator
      *            an accumulator function to be invoked on each item emitted by the source Observable, whose
      *            result will be emitted to {@link Observer}s via {@link Observer#onNext onNext} and used in the
@@ -9290,9 +9290,9 @@ public final Observable<T> scan(Func2<T, T, T> accumulator) {
      * <pre><code>
      * Observable&lt;T> source = ...
      * Observable.defer(() -> source.scan(new ArrayList&lt;>(), (list, item) -> list.add(item)));
-     * 
+     *
      * // alternatively, by using compose to stay fluent
-     * 
+     *
      * source.compose(o ->
      *     Observable.defer(() -> o.scan(new ArrayList&lt;>(), (list, item) -> list.add(item)))
      * );
@@ -9304,7 +9304,7 @@ public final Observable<T> scan(Func2<T, T, T> accumulator) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code scan} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the initial, accumulator and result type
      * @param initialValue
      *            the initial (seed) accumulator item
@@ -9349,21 +9349,21 @@ public final Observable<T> serialize() {
 
     /**
      * Returns a new {@link Observable} that multicasts (shares) the original {@link Observable}. As long as
-     * there is at least one {@link Subscriber} this {@link Observable} will be subscribed and emitting data. 
-     * When all subscribers have unsubscribed it will unsubscribe from the source {@link Observable}. 
+     * there is at least one {@link Subscriber} this {@link Observable} will be subscribed and emitting data.
+     * When all subscribers have unsubscribed it will unsubscribe from the source {@link Observable}.
      * <p>
      * This is an alias for {@link #publish()}.{@link ConnectableObservable#refCount()}.
      * <p>
      * <img width="640" height="510" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/publishRefCount.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator honors backpressure and and expects the source {@code Observable} to honor backpressure as well. 
-     *  If this expectation is violated, the operator will signal a {@code MissingBackpressureException} to 
+     *  <dd>The operator honors backpressure and and expects the source {@code Observable} to honor backpressure as well.
+     *  If this expectation is violated, the operator will signal a {@code MissingBackpressureException} to
      *  its {@code Subscriber}s.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code share} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an {@code Observable} that upon connection causes the source {@code Observable} to emit items
      *         to its {@link Observer}s
      * @see <a href="http://reactivex.io/documentation/operators/refcount.html">ReactiveX operators documentation: RefCount</a>
@@ -9371,7 +9371,7 @@ public final Observable<T> serialize() {
     public final Observable<T> share() {
         return publish().refCount();
     }
-    
+
     /**
      * Returns an Observable that emits the single item emitted by the source Observable, if that Observable
      * emits only a single item. If the source Observable emits more than one item or no items, notify of an
@@ -9385,7 +9385,7 @@ public final Observable<T> share() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code single} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits the single item emitted by the source Observable
      * @throws IllegalArgumentException
      *             if the source emits more than one item
@@ -9411,7 +9411,7 @@ public final Observable<T> single() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code single} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param predicate
      *            a predicate function to evaluate items emitted by the source Observable
      * @return an Observable that emits the single item emitted by the source Observable that matches the
@@ -9439,7 +9439,7 @@ public final Observable<T> single(Func1<? super T, Boolean> predicate) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code singleOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param defaultValue
      *            a default value to emit if the source Observable emits no item
      * @return an Observable that emits the single item emitted by the source Observable, or a default item if
@@ -9466,7 +9466,7 @@ public final Observable<T> singleOrDefault(T defaultValue) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code singleOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param defaultValue
      *            a default item to emit if the source Observable emits no matching items
      * @param predicate
@@ -9493,7 +9493,7 @@ public final Observable<T> singleOrDefault(T defaultValue, Func1<? super T, Bool
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code skip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the number of items to skip
      * @return an Observable that is identical to the source Observable except that it does not emit the first
@@ -9516,7 +9516,7 @@ public final Observable<T> skip(int count) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code skip} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param time
      *            the length of the time window to skip
      * @param unit
@@ -9541,7 +9541,7 @@ public final Observable<T> skip(long time, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param time
      *            the length of the time window to skip
      * @param unit
@@ -9572,7 +9572,7 @@ public final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code skipLast} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            number of items to drop from the end of the source sequence
      * @return an Observable that emits the items emitted by the source Observable except for the dropped ones
@@ -9599,7 +9599,7 @@ public final Observable<T> skipLast(int count) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code skipLast} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param time
      *            the length of the time window
      * @param unit
@@ -9653,7 +9653,7 @@ public final Observable<T> skipLast(long time, TimeUnit unit, Scheduler schedule
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code skipUntil} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U> the element type of the other Observable
      * @param other
      *            the second Observable that has to emit an item before the source Observable's elements begin
@@ -9678,7 +9678,7 @@ public final <U> Observable<T> skipUntil(Observable<U> other) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code skipWhile} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param predicate
      *            a function to test each item emitted from the source Observable
      * @return an Observable that begins emitting items emitted by the source Observable when the specified
@@ -9702,7 +9702,7 @@ public final Observable<T> skipWhile(Func1<? super T, Boolean> predicate) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param values
      *            an Observable that contains the items you want the modified Observable to emit first
      * @return an Observable that emits the items in the specified {@link Observable} and then emits the items
@@ -9726,7 +9726,7 @@ public final Observable<T> startWith(Observable<T> values) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param values
      *            an Iterable that contains the items you want the modified Observable to emit first
      * @return an Observable that emits the items in the specified {@link Iterable} and then emits the items
@@ -9750,7 +9750,7 @@ public final Observable<T> startWith(Iterable<T> values) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            the item to emit
      * @return an Observable that emits the specified item before it begins to emit items emitted by the source
@@ -9774,7 +9774,7 @@ public final Observable<T> startWith(T t1) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            the first item to emit
      * @param t2
@@ -9800,7 +9800,7 @@ public final Observable<T> startWith(T t1, T t2) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            the first item to emit
      * @param t2
@@ -9828,7 +9828,7 @@ public final Observable<T> startWith(T t1, T t2, T t3) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            the first item to emit
      * @param t2
@@ -9858,7 +9858,7 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            the first item to emit
      * @param t2
@@ -9890,7 +9890,7 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            the first item to emit
      * @param t2
@@ -9924,7 +9924,7 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            the first item to emit
      * @param t2
@@ -9960,7 +9960,7 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            the first item to emit
      * @param t2
@@ -9998,7 +9998,7 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code startWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            the first item to emit
      * @param t2
@@ -10026,8 +10026,8 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
     }
 
     /**
-     * Subscribes to an Observable and ignores {@code onNext} and {@code onCompleted} emissions. If an {@code onError} emission arrives then 
-     * {@link OnErrorNotImplementedException} is thrown. 
+     * Subscribes to an Observable and ignores {@code onNext} and {@code onCompleted} emissions. If an {@code onError} emission arrives then
+     * {@link OnErrorNotImplementedException} is thrown.
      * <dl>
      *  <dd><b>Backpressure:</b><dt>
      *  <dd>The operator consumes the source {@code Observable} in an unbounded manner (i.e., no
@@ -10035,7 +10035,7 @@ public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before
      *         the Observable has finished sending them
      * @throws OnErrorNotImplementedException
@@ -10058,7 +10058,7 @@ public final Subscription subscribe() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onNext
      *             the {@code Action1<T>} you have designed to accept emissions from the Observable
      * @return a {@link Subscription} reference with which the {@link Observer} can stop receiving items before
@@ -10089,7 +10089,7 @@ public final Subscription subscribe(final Action1<? super T> onNext) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onNext
      *             the {@code Action1<T>} you have designed to accept emissions from the Observable
      * @param onError
@@ -10124,7 +10124,7 @@ public final Subscription subscribe(final Action1<? super T> onNext, final Actio
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onNext
      *             the {@code Action1<T>} you have designed to accept emissions from the Observable
      * @param onError
@@ -10197,7 +10197,7 @@ public final Subscription subscribe(final Observer<? super T> observer) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code unsafeSubscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param subscriber
      *              the Subscriber that will handle emissions and notifications from the Observable
      * @return a {@link Subscription} reference with which the {@link Subscriber} can stop receiving items
@@ -10224,7 +10224,7 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
                 // TODO could the hook be the cause of the error in the on error handling.
                 RxJavaHooks.onObservableError(r);
                 // TODO why aren't we throwing the hook's return value.
-                throw r; // NOPMD 
+                throw r; // NOPMD
             }
             return Subscriptions.unsubscribed();
         }
@@ -10255,7 +10255,7 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param subscriber
      *            the {@link Subscriber} that will handle emissions and notifications from the Observable
      * @return a {@link Subscription} reference with which Subscribers that are {@link Observer}s can
@@ -10273,7 +10273,7 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
     public final Subscription subscribe(Subscriber<? super T> subscriber) {
         return Observable.subscribe(subscriber, this);
     }
-    
+
     static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
      // validate and proceed
         if (subscriber == null) {
@@ -10286,10 +10286,10 @@ static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T
              * so I won't mention that in the exception
              */
         }
-        
+
         // new Subscriber so onStart it
         subscriber.onStart();
-        
+
         /*
          * See https://github.com/ReactiveX/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls
          * to user code from within an Observer"
@@ -10300,7 +10300,7 @@ static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T
             subscriber = new SafeSubscriber<T>(subscriber);
         }
 
-        // The code below is exactly the same an unsafeSubscribe but not used because it would 
+        // The code below is exactly the same an unsafeSubscribe but not used because it would
         // add a significant depth to already huge call stacks.
         try {
             // allow the hook to intercept and/or decorate
@@ -10324,7 +10324,7 @@ static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T
                     // TODO could the hook be the cause of the error in the on error handling.
                     RxJavaHooks.onObservableError(r);
                     // TODO why aren't we throwing the hook's return value.
-                    throw r; // NOPMD 
+                    throw r; // NOPMD
                 }
             }
             return Subscriptions.unsubscribed();
@@ -10342,7 +10342,7 @@ static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param scheduler
      *            the {@link Scheduler} to perform subscription actions on
      * @return the source Observable modified so that its subscriptions happen on the
@@ -10376,7 +10376,7 @@ public final Observable<T> subscribeOn(Scheduler scheduler) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code switchMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the element type of the inner Observables and the output
      * @param func
      *            a function that, when applied to an item emitted by the source Observable, returns an
@@ -10407,7 +10407,7 @@ public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code switchMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the element type of the inner Observables and the output
      * @param func
      *            a function that, when applied to an item emitted by the source Observable, returns an
@@ -10423,7 +10423,7 @@ public final <R> Observable<R> switchMapDelayError(Func1<? super T, ? extends Ob
     }
 
     /**
-     * Returns an Observable that emits only the first {@code count} items emitted by the source Observable. If the source emits fewer than 
+     * Returns an Observable that emits only the first {@code count} items emitted by the source Observable. If the source emits fewer than
      * {@code count} items then all of its items are emitted.
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/take.png" alt="">
@@ -10439,7 +10439,7 @@ public final <R> Observable<R> switchMapDelayError(Func1<? super T, ? extends Ob
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code take} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum number of items to emit
      * @return an Observable that emits only the first {@code count} items emitted by the source Observable, or
@@ -10462,7 +10462,7 @@ public final Observable<T> take(final int count) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code take} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param time
      *            the length of the time window
      * @param unit
@@ -10486,7 +10486,7 @@ public final Observable<T> take(long time, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param time
      *            the length of the time window
      * @param unit
@@ -10513,7 +10513,7 @@ public final Observable<T> take(long time, TimeUnit unit, Scheduler scheduler) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code takeFirst} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param predicate
      *            the condition any item emitted by the source Observable has to satisfy
      * @return an Observable that emits only the very first item emitted by the source Observable that satisfies
@@ -10526,7 +10526,7 @@ public final Observable<T> takeFirst(Func1<? super T, Boolean> predicate) {
     }
 
     /**
-     * Returns an Observable that emits at most the last {@code count} items emitted by the source Observable. If the source emits fewer than 
+     * Returns an Observable that emits at most the last {@code count} items emitted by the source Observable. If the source emits fewer than
      * {@code count} items then all of its items are emitted.
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLast.n.png" alt="">
@@ -10537,7 +10537,7 @@ public final Observable<T> takeFirst(Func1<? super T, Boolean> predicate) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLast} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum number of items to emit from the end of the sequence of items emitted by the source
      *            Observable
@@ -10558,7 +10558,7 @@ public final Observable<T> takeLast(final int count) {
 
     /**
      * Returns an Observable that emits at most a specified number of items from the source Observable that were
-     * emitted in a specified window of time before the Observable completed. 
+     * emitted in a specified window of time before the Observable completed.
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/takeLast.tn.png" alt="">
      * <dl>
@@ -10568,7 +10568,7 @@ public final Observable<T> takeLast(final int count) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLast} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum number of items to emit
      * @param time
@@ -10596,7 +10596,7 @@ public final Observable<T> takeLast(int count, long time, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum number of items to emit
      * @param time
@@ -10625,13 +10625,13 @@ public final Observable<T> takeLast(int count, long time, TimeUnit unit, Schedul
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
      *  unbounded manner (i.e., no backpressure is applied to it) but note that this <em>may</em>
-     *  lead to {@code OutOfMemoryError} due to internal buffer bloat. 
+     *  lead to {@code OutOfMemoryError} due to internal buffer bloat.
      *  Consider using {@link #takeLast(int, long, TimeUnit)} in this case.</dd>
      *  behavior.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLast} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param time
      *            the length of the time window
      * @param unit
@@ -10654,12 +10654,12 @@ public final Observable<T> takeLast(long time, TimeUnit unit) {
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an
      *  unbounded manner (i.e., no backpressure is applied to it) but note that this <em>may</em>
-     *  lead to {@code OutOfMemoryError} due to internal buffer bloat. 
+     *  lead to {@code OutOfMemoryError} due to internal buffer bloat.
      *  Consider using {@link #takeLast(int, long, TimeUnit, Scheduler)} in this case.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param time
      *            the length of the time window
      * @param unit
@@ -10687,7 +10687,7 @@ public final Observable<T> takeLast(long time, TimeUnit unit, Scheduler schedule
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLastBuffer} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum number of items to emit in the list
      * @return an Observable that emits a single list containing at most the last {@code count} elements emitted by the
@@ -10710,7 +10710,7 @@ public final Observable<List<T>> takeLastBuffer(int count) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLastBuffer} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum number of items to emit
      * @param time
@@ -10739,7 +10739,7 @@ public final Observable<List<T>> takeLastBuffer(int count, long time, TimeUnit u
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum number of items to emit
      * @param time
@@ -10769,7 +10769,7 @@ public final Observable<List<T>> takeLastBuffer(int count, long time, TimeUnit u
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code takeLastBuffer} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param time
      *            the length of the time window
      * @param unit
@@ -10795,7 +10795,7 @@ public final Observable<List<T>> takeLastBuffer(long time, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param time
      *            the length of the time window
      * @param unit
@@ -10823,7 +10823,7 @@ public final Observable<List<T>> takeLastBuffer(long time, TimeUnit unit, Schedu
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code takeUntil} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param other
      *            the Observable whose first emitted item will cause {@code takeUntil} to stop emitting items
      *            from the source Observable
@@ -10848,7 +10848,7 @@ public final <E> Observable<T> takeUntil(Observable<? extends E> other) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code takeWhile} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param predicate
      *            a function that evaluates an item emitted by the source Observable and returns a Boolean
      * @return an Observable that emits the items from the source Observable so long as each item satisfies the
@@ -10868,7 +10868,7 @@ public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate)
      * <p>
      * The difference between this operator and {@link #takeWhile(Func1)} is that here, the condition is
      * evaluated <em>after</em> the item is emitted.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator is a pass-through for backpressure; the backpressure behavior is determined by the upstream
@@ -10876,8 +10876,8 @@ public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate)
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code takeWhile} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
-     * @param stopPredicate 
+     *
+     * @param stopPredicate
      *            a function that evaluates an item emitted by the source Observable and returns a Boolean
      * @return an Observable that first emits items emitted by the source Observable, checks the specified
      *         condition after each item, and then completes when the condition is satisfied.
@@ -10888,7 +10888,7 @@ public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate)
     public final Observable<T> takeUntil(final Func1<? super T, Boolean> stopPredicate) {
         return lift(new OperatorTakeUntilPredicate<T>(stopPredicate));
     }
-    
+
     /**
      * Returns an Observable that emits only the first item emitted by the source Observable during sequential
      * time windows of a specified duration.
@@ -10903,7 +10903,7 @@ public final Observable<T> takeUntil(final Func1<? super T, Boolean> stopPredica
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code throttleFirst} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param windowDuration
      *            time to wait before emitting another item after emitting the last item
      * @param unit
@@ -10930,7 +10930,7 @@ public final Observable<T> throttleFirst(long windowDuration, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param skipDuration
      *            time to wait before emitting another item after emitting the last item
      * @param unit
@@ -10960,7 +10960,7 @@ public final Observable<T> throttleFirst(long skipDuration, TimeUnit unit, Sched
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code throttleLast} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param intervalDuration
      *            duration of windows within which the last item emitted by the source Observable will be
      *            emitted
@@ -10989,7 +10989,7 @@ public final Observable<T> throttleLast(long intervalDuration, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param intervalDuration
      *            duration of windows within which the last item emitted by the source Observable will be
      *            emitted
@@ -11029,7 +11029,7 @@ public final Observable<T> throttleLast(long intervalDuration, TimeUnit unit, Sc
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code throttleWithTimeout} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            the length of the window of time that must pass after the emission of an item from the source
      *            Observable in which that Observable emits no items in order for the item to be emitted by the
@@ -11068,7 +11068,7 @@ public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            the length of the window of time that must pass after the emission of an item from the source
      *            Observable in which that Observable emits no items in order for the item to be emitted by the
@@ -11100,7 +11100,7 @@ public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit, Sche
      *  <dd>{@code timeInterval} does not operate on any particular scheduler but uses the current time
      *  from the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits time interval information items
      * @see <a href="http://reactivex.io/documentation/operators/timeinterval.html">ReactiveX operators documentation: TimeInterval</a>
      */
@@ -11121,7 +11121,7 @@ public final Observable<TimeInterval<T>> timeInterval() {
      *  <dd>The operator does not operate on any particular scheduler but uses the current time
      *  from the specified {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param scheduler
      *            the {@link Scheduler} used to compute time intervals
      * @return an Observable that emits time interval information items
@@ -11145,7 +11145,7 @@ public final Observable<TimeInterval<T>> timeInterval(Scheduler scheduler) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U>
      *            the first timeout value type (ignored)
      * @param <V>
@@ -11175,13 +11175,13 @@ public final <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTi
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U>
      *            the first timeout value type (ignored)
      * @param <V>
@@ -11221,13 +11221,13 @@ public final <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTi
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <V>
      *            the timeout value type (ignored)
      * @param timeoutSelector
@@ -11254,13 +11254,13 @@ public final <V> Observable<T> timeout(Func1<? super T, ? extends Observable<V>>
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code immediate} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <V>
      *            the timeout value type (ignored)
      * @param timeoutSelector
@@ -11290,7 +11290,7 @@ public final <V> Observable<T> timeout(Func1<? super T, ? extends Observable<V>>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            maximum duration between emitted items before a timeout occurs
      * @param timeUnit
@@ -11312,13 +11312,13 @@ public final Observable<T> timeout(long timeout, TimeUnit timeUnit) {
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code timeout} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            maximum duration between items before a timeout occurs
      * @param timeUnit
@@ -11341,13 +11341,13 @@ public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<?
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream. The {@code Observable}
-     *  sources are expected to honor backpressure as well. 
+     *  sources are expected to honor backpressure as well.
      *  If any of the source {@code Observable}s violate this, it <em>may</em> throw an
      *  {@code IllegalStateException} when the source {@code Observable} completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            maximum duration between items before a timeout occurs
      * @param timeUnit
@@ -11378,7 +11378,7 @@ public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            maximum duration between items before a timeout occurs
      * @param timeUnit
@@ -11406,7 +11406,7 @@ public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Scheduler sc
      *  <dd>{@code timestamp} does not operate on any particular scheduler but uses the current time
      *  from the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits timestamped items from the source Observable
      * @see <a href="http://reactivex.io/documentation/operators/timestamp.html">ReactiveX operators documentation: Timestamp</a>
      */
@@ -11427,7 +11427,7 @@ public final Observable<Timestamped<T>> timestamp() {
      *  <dd>The operator does not operate on any particular scheduler but uses the current time
      *  from the specified {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param scheduler
      *            the {@link Scheduler} to use as a time source
      * @return an Observable that emits timestamped items from the source Observable with timestamps provided by
@@ -11476,7 +11476,7 @@ public final BlockingObservable<T> toBlocking() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toList} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return an Observable that emits a single item: a List containing all of the items emitted by the source
      *         Observable
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
@@ -11499,7 +11499,7 @@ public final Observable<List<T>> toList() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <K> the key type of the Map
      * @param keySelector
      *            the function that extracts the key from a source item to be used in the HashMap
@@ -11526,7 +11526,7 @@ public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySe
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <K> the key type of the Map
      * @param <V> the value type of the Map
      * @param keySelector
@@ -11553,7 +11553,7 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <K> the key type of the Map
      * @param <V> the value type of the Map
      * @param keySelector
@@ -11581,7 +11581,7 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <K> the key type of the Map
      * @param keySelector
      *            the function that extracts the key from the source items to be used as key in the HashMap
@@ -11606,7 +11606,7 @@ public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <K> the key type of the Map
      * @param <V> the value type of the Map
      * @param keySelector
@@ -11634,7 +11634,7 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <K> the key type of the Map
      * @param <V> the value type of the Map
      * @param keySelector
@@ -11664,7 +11664,7 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toMultiMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <K> the key type of the Map
      * @param <V> the value type of the Map
      * @param keySelector
@@ -11696,7 +11696,7 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toSortedList} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @throws ClassCastException
      *             if any item emitted by the Observable does not implement {@link Comparable} with respect to
      *             all other items emitted by the Observable
@@ -11720,7 +11720,7 @@ public final Observable<List<T>> toSortedList() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toSortedList} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param sortFunction
      *            a function that compares two items emitted by the source Observable and returns an Integer
      *            that indicates their sort order
@@ -11745,8 +11745,8 @@ public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Intege
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toSortedList} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
-     * @param initialCapacity 
+     *
+     * @param initialCapacity
      *             the initial capacity of the ArrayList used to accumulate items before sorting
      * @return an Observable that emits a list that contains the items emitted by the source Observable in
      *         sorted order
@@ -11773,11 +11773,11 @@ public final Observable<List<T>> toSortedList(int initialCapacity) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code toSortedList} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param sortFunction
      *            a function that compares two items emitted by the source Observable and returns an Integer
      *            that indicates their sort order
-     * @param initialCapacity 
+     * @param initialCapacity
      *             the initial capacity of the ArrayList used to accumulate items before sorting
      * @return an Observable that emits a list that contains the items emitted by the source Observable in
      *         sorted order
@@ -11850,7 +11850,7 @@ public final Observable<T> sorted(Func2<? super T, ? super T, Integer> sortFunct
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param scheduler
      *            the {@link Scheduler} to perform unsubscription actions on
      * @return the source Observable modified so that its unsubscriptions happen on the specified
@@ -11866,7 +11866,7 @@ public final Observable<T> unsubscribeOn(Scheduler scheduler) {
      * function only when the source Observable (this instance) emits an item.
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/withLatestFrom.png" alt="">
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator is a pass-through for backpressure: the backpressure support
@@ -11875,7 +11875,7 @@ public final Observable<T> unsubscribeOn(Scheduler scheduler) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator, by default, doesn't run any particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U> the element type of the other Observable
      * @param <R> the result type of the combination
      * @param other
@@ -11898,12 +11898,12 @@ public final <U, R> Observable<R> withLatestFrom(Observable<? extends U> other,
     /**
      * Combines the value emission from this Observable with the latest emissions from the
      * other Observables via a function to produce the output item.
-     * 
+     *
      * <p>Note that this operator doesn't emit anything until all other sources have produced at
      * least one value. The resulting emission only happens when this Observable emits (and
-     * not when any of the other sources emit, unlike combineLatest). 
+     * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
@@ -11930,12 +11930,12 @@ public final <T1, T2, R> Observable<R> withLatestFrom(Observable<T1> o1, Observa
     /**
      * Combines the value emission from this Observable with the latest emissions from the
      * other Observables via a function to produce the output item.
-     * 
+     *
      * <p>Note that this operator doesn't emit anything until all other sources have produced at
      * least one value. The resulting emission only happens when this Observable emits (and
-     * not when any of the other sources emit, unlike combineLatest). 
+     * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
@@ -11958,22 +11958,22 @@ public final <T1, T2, R> Observable<R> withLatestFrom(Observable<T1> o1, Observa
      */
     @Experimental
     public final <T1, T2, T3, R> Observable<R> withLatestFrom(
-            Observable<T1> o1, Observable<T2> o2, 
-            Observable<T3> o3, 
+            Observable<T1> o1, Observable<T2> o2,
+            Observable<T3> o3,
             Func4<? super T, ? super T1, ? super T2, ? super T3, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this, 
+        return create(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3 }, null, Functions.fromFunc(combiner)));
     }
 
     /**
      * Combines the value emission from this Observable with the latest emissions from the
      * other Observables via a function to produce the output item.
-     * 
+     *
      * <p>Note that this operator doesn't emit anything until all other sources have produced at
      * least one value. The resulting emission only happens when this Observable emits (and
-     * not when any of the other sources emit, unlike combineLatest). 
+     * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
@@ -11998,21 +11998,21 @@ public final <T1, T2, T3, R> Observable<R> withLatestFrom(
      */
     @Experimental
     public final <T1, T2, T3, T4, R> Observable<R> withLatestFrom(
-            Observable<T1> o1, Observable<T2> o2, 
-            Observable<T3> o3, Observable<T4> o4, 
+            Observable<T1> o1, Observable<T2> o2,
+            Observable<T3> o3, Observable<T4> o4,
             Func5<? super T, ? super T1, ? super T2, ? super T3, ? super T4, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this, 
+        return create(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3, o4 }, null, Functions.fromFunc(combiner)));
     }
     /**
      * Combines the value emission from this Observable with the latest emissions from the
      * other Observables via a function to produce the output item.
-     * 
+     *
      * <p>Note that this operator doesn't emit anything until all other sources have produced at
      * least one value. The resulting emission only happens when this Observable emits (and
-     * not when any of the other sources emit, unlike combineLatest). 
+     * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
@@ -12039,23 +12039,23 @@ public final <T1, T2, T3, T4, R> Observable<R> withLatestFrom(
      */
     @Experimental
     public final <T1, T2, T3, T4, T5, R> Observable<R> withLatestFrom(
-            Observable<T1> o1, Observable<T2> o2, 
+            Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3, Observable<T4> o4,
             Observable<T5> o5,
             Func6<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this, 
+        return create(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3, o4, o5 }, null, Functions.fromFunc(combiner)));
     }
 
     /**
      * Combines the value emission from this Observable with the latest emissions from the
      * other Observables via a function to produce the output item.
-     * 
+     *
      * <p>Note that this operator doesn't emit anything until all other sources have produced at
      * least one value. The resulting emission only happens when this Observable emits (and
-     * not when any of the other sources emit, unlike combineLatest). 
+     * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
@@ -12084,23 +12084,23 @@ public final <T1, T2, T3, T4, T5, R> Observable<R> withLatestFrom(
      */
     @Experimental
     public final <T1, T2, T3, T4, T5, T6, R> Observable<R> withLatestFrom(
-            Observable<T1> o1, Observable<T2> o2, 
+            Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3, Observable<T4> o4,
             Observable<T5> o5, Observable<T6> o6,
             Func7<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this, 
+        return create(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3, o4, o5, o6 }, null, Functions.fromFunc(combiner)));
     }
 
     /**
      * Combines the value emission from this Observable with the latest emissions from the
      * other Observables via a function to produce the output item.
-     * 
+     *
      * <p>Note that this operator doesn't emit anything until all other sources have produced at
      * least one value. The resulting emission only happens when this Observable emits (and
-     * not when any of the other sources emit, unlike combineLatest). 
+     * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
@@ -12131,24 +12131,24 @@ public final <T1, T2, T3, T4, T5, T6, R> Observable<R> withLatestFrom(
      */
     @Experimental
     public final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> withLatestFrom(
-            Observable<T1> o1, Observable<T2> o2, 
+            Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3, Observable<T4> o4,
             Observable<T5> o5, Observable<T6> o6,
             Observable<T7> o7,
             Func8<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this, 
+        return create(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7 }, null, Functions.fromFunc(combiner)));
     }
 
     /**
      * Combines the value emission from this Observable with the latest emissions from the
      * other Observables via a function to produce the output item.
-     * 
+     *
      * <p>Note that this operator doesn't emit anything until all other sources have produced at
      * least one value. The resulting emission only happens when this Observable emits (and
-     * not when any of the other sources emit, unlike combineLatest). 
+     * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
@@ -12181,24 +12181,24 @@ public final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> withLatestFrom(
      */
     @Experimental
     public final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> withLatestFrom(
-            Observable<T1> o1, Observable<T2> o2, 
+            Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3, Observable<T4> o4,
             Observable<T5> o5, Observable<T6> o6,
             Observable<T7> o7, Observable<T8> o8,
             Func9<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this, 
+        return create(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7, o8 }, null, Functions.fromFunc(combiner)));
     }
 
     /**
      * Combines the value emission from this Observable with the latest emissions from the
      * other Observables via a function to produce the output item.
-     * 
+     *
      * <p>Note that this operator doesn't emit anything until all other sources have produced at
      * least one value. The resulting emission only happens when this Observable emits (and
-     * not when any of the other sources emit, unlike combineLatest). 
+     * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
@@ -12206,7 +12206,7 @@ public final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> withLatestFrom(
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the result value type
      * @param others the array of other sources
      * @param combiner the function called with an array of values from each participating observable
@@ -12222,12 +12222,12 @@ public final <R> Observable<R> withLatestFrom(Observable<?>[] others, FuncN<R> c
     /**
      * Combines the value emission from this Observable with the latest emissions from the
      * other Observables via a function to produce the output item.
-     * 
+     *
      * <p>Note that this operator doesn't emit anything until all other sources have produced at
      * least one value. The resulting emission only happens when this Observable emits (and
-     * not when any of the other sources emit, unlike combineLatest). 
+     * not when any of the other sources emit, unlike combineLatest).
      * If a source doesn't produce any value and just completes, the sequence is completed immediately.
-     * 
+     *
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator is a pass-through for backpressure behavior between the source {@code Observable}
@@ -12235,7 +12235,7 @@ public final <R> Observable<R> withLatestFrom(Observable<?>[] others, FuncN<R> c
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This operator does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the result value type
      * @param others the iterable of other sources
      * @param combiner the function called with an array of values from each participating observable
@@ -12256,15 +12256,15 @@ public final <R> Observable<R> withLatestFrom(Iterable<Observable<?>> others, Fu
      * <img width="640" height="460" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window1.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
-     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner.
+     *  The returned {@code Observable} doesn't support backpressure as it uses
      *  the {@code closingSelector} to control the creation of windows. The returned inner {@code Observable}s honor
      *  backpressure but have an unbounded inner buffer that <em>may</em> lead to {@code OutOfMemoryError}
      *  if left unconsumed.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <TClosing> the element type of the boundary Observable
      * @param closingSelector
      *            a {@link Func0} that returns an {@code Observable} that governs the boundary between windows.
@@ -12292,7 +12292,7 @@ public final <TClosing> Observable<Observable<T>> window(Func0<? extends Observa
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum size of each window before it should be emitted
      * @return an Observable that emits connected, non-overlapping windows, each containing at most
@@ -12318,7 +12318,7 @@ public final Observable<Observable<T>> window(int count) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param count
      *            the maximum size of each window before it should be emitted
      * @param skip
@@ -12349,15 +12349,15 @@ public final Observable<Observable<T>> window(int count, int skip) {
      * <img width="640" height="335" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window7.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
-     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner.
+     *  The returned {@code Observable} doesn't support backpressure as it uses
      *  time to control the creation of windows. The returned inner {@code Observable}s honor
      *  backpressure but have an unbounded inner buffer that <em>may</em> lead to {@code OutOfMemoryError}
      *  if left unconsumed.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each window collects items before it should be emitted
      * @param timeshift
@@ -12381,15 +12381,15 @@ public final Observable<Observable<T>> window(long timespan, long timeshift, Tim
      * <img width="640" height="335" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window7.s.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
-     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner.
+     *  The returned {@code Observable} doesn't support backpressure as it uses
      *  time to control the creation of windows. The returned inner {@code Observable}s honor
      *  backpressure but have an unbounded inner buffer that <em>may</em> lead to {@code OutOfMemoryError}
      *  if left unconsumed.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each window collects items before it should be emitted
      * @param timeshift
@@ -12404,7 +12404,7 @@ public final Observable<Observable<T>> window(long timespan, long timeshift, Tim
     public final Observable<Observable<T>> window(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
         return window(timespan, timeshift, unit, Integer.MAX_VALUE, scheduler);
     }
-    
+
     /**
      * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
      * Observable starts a new window periodically, as determined by the {@code timeshift} argument or a maximum
@@ -12416,14 +12416,14 @@ public final Observable<Observable<T>> window(long timespan, long timeshift, Tim
      * <img width="640" height="335" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window7.s.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
-     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner.
+     *  The returned {@code Observable} doesn't support backpressure as it uses
      *  time to control the creation of windows. The returned inner {@code Observable}s honor
      *  backpressure and may hold up to {@code count} elements at most.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each window collects items before it should be emitted
      * @param timeshift
@@ -12450,14 +12450,14 @@ public final Observable<Observable<T>> window(long timespan, long timeshift, Tim
      * <img width="640" height="375" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window5.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
-     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner.
+     *  The returned {@code Observable} doesn't support backpressure as it uses
      *  time to control the creation of windows. The returned inner {@code Observable}s honor
      *  backpressure and may hold up to {@code count} elements at most.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each window collects items before it should be emitted and replaced with a
      *            new window
@@ -12481,14 +12481,14 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit) {
      * <img width="640" height="370" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window6.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
-     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner.
+     *  The returned {@code Observable} doesn't support backpressure as it uses
      *  time to control the creation of windows. The returned inner {@code Observable}s honor
      *  backpressure and may hold up to {@code count} elements at most.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each window collects items before it should be emitted and replaced with a
      *            new window
@@ -12515,14 +12515,14 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int
      * <img width="640" height="370" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window6.s.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
-     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner.
+     *  The returned {@code Observable} doesn't support backpressure as it uses
      *  time to control the creation of windows. The returned inner {@code Observable}s honor
      *  backpressure and may hold up to {@code count} elements at most.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each window collects items before it should be emitted and replaced with a
      *            new window
@@ -12550,15 +12550,15 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int
      * <img width="640" height="375" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window5.s.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner. 
-     *  The returned {@code Observable} doesn't support backpressure as it uses 
+     *  <dd>The operator consumes the source {@code Observable} in an unbounded manner.
+     *  The returned {@code Observable} doesn't support backpressure as it uses
      *  time to control the creation of windows. The returned inner {@code Observable}s honor
      *  backpressure but have an unbounded inner buffer that <em>may</em> lead to {@code OutOfMemoryError}
      *  if left unconsumed.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timespan
      *            the period of time each window collects items before it should be emitted and replaced with a
      *            new window
@@ -12584,13 +12584,13 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit, Sche
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The outer Observable of this operator doesn't support backpressure because the emission of new
-     *  inner Observables are controlled by the {@code windowOpenings} Observable. 
+     *  inner Observables are controlled by the {@code windowOpenings} Observable.
      *  The inner Observables honor backpressure and buffer everything until the associated closing
      *  Observable signals or completes.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <TOpening> the element type of the window-opening Observable
      * @param <TClosing> the element type of the window-closing Observables
      * @param windowOpenings
@@ -12619,7 +12619,7 @@ public final <TOpening, TClosing> Observable<Observable<T>> window(Observable<?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>This version of {@code window} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <U>
      *            the window element type (ignored)
      * @param boundary
@@ -12649,7 +12649,7 @@ public final <U> Observable<Observable<T>> window(Observable<U> boundary) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zipWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T2>
      *            the type of items in the {@code other} Iterable
      * @param <R>
@@ -12672,18 +12672,18 @@ public final <T2, R> Observable<R> zipWith(Iterable<? extends T2> other, Func2<?
      * values, one each from the source Observable and another specified Observable.
      * <p>
      * <p>
-     * The operator subscribes to its sources in order they are specified and completes eagerly if 
-     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it 
-     * is possible those other sources will never be able to run to completion (and thus not calling 
+     * The operator subscribes to its sources in order they are specified and completes eagerly if
+     * one of the sources is shorter than the rest while unsubscribing the other sources. Therefore, it
+     * is possible those other sources will never be able to run to completion (and thus not calling
      * {@code doOnCompleted()}). This can also happen if the sources are exactly the same length; if
      * source A completes and B has been consumed and is about to complete, the operator detects A won't
      * be sending further values and it will unsubscribe B immediately. For example:
      * <pre><code>range(1, 5).doOnCompleted(action1).zipWith(range(6, 5).doOnCompleted(action2), (a, b) -&gt; a + b)</code></pre>
      * {@code action1} will be called but {@code action2} won't.
      * <br>To work around this termination property,
-     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion 
+     * use {@code doOnUnsubscribed()} as well or use {@code using()} to do cleanup in case of completion
      * or unsubscription.
-     * 
+     *
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/zip.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b><dt>
@@ -12693,7 +12693,7 @@ public final <T2, R> Observable<R> zipWith(Iterable<? extends T2> other, Func2<?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code zipWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T2>
      *            the type of items emitted by the {@code other} Observable
      * @param <R>
diff --git a/src/main/java/rx/Observer.java b/src/main/java/rx/Observer.java
index 8c7eca5c77..28d29e53fa 100644
--- a/src/main/java/rx/Observer.java
+++ b/src/main/java/rx/Observer.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -22,7 +22,7 @@
  * {@code Observable} calls the Observer's {@link #onNext} method to provide notifications. A well-behaved
  * {@code Observable} will call an Observer's {@link #onCompleted} method exactly once or the Observer's
  * {@link #onError} method exactly once.
- * 
+ *
  * @see <a href="http://reactivex.io/documentation/observable.html">ReactiveX documentation: Observable</a>
  * @param <T>
  *          the type of item the Observer expects to observe
@@ -41,7 +41,7 @@ public interface Observer<T> {
      * <p>
      * If the {@link Observable} calls this method, it will not thereafter call {@link #onNext} or
      * {@link #onCompleted}.
-     * 
+     *
      * @param e
      *          the exception encountered by the Observable
      */
@@ -54,7 +54,7 @@ public interface Observer<T> {
      * <p>
      * The {@code Observable} will not call this method again after it calls either {@link #onCompleted} or
      * {@link #onError}.
-     * 
+     *
      * @param t
      *          the item emitted by the Observable
      */
diff --git a/src/main/java/rx/Producer.java b/src/main/java/rx/Producer.java
index fb7f211e7c..7fe1d83663 100644
--- a/src/main/java/rx/Producer.java
+++ b/src/main/java/rx/Producer.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -19,10 +19,10 @@
  * Interface that establishes a request-channel between an Observable and a Subscriber and allows
  * the Subscriber to request a certain amount of items from the Observable (otherwise known as
  * backpressure).
- * 
+ *
  * <p>The request amount only affects calls to {@link Subscriber#onNext(Object)}; onError and onCompleted may appear without
  * requests.
- * 
+ *
  * <p>However, backpressure is somewhat optional in RxJava 1.x and Subscribers may not
  * receive a Producer via their {@link Subscriber#setProducer(Producer)} method and will run
  * in unbounded mode. Depending on the chain of operators, this can lead to {@link rx.exceptions.MissingBackpressureException}.
@@ -33,15 +33,15 @@ public interface Producer {
      * Request a certain maximum number of items from this Producer. This is a way of requesting backpressure.
      * To disable backpressure, pass {@code Long.MAX_VALUE} to this method.
      * <p>
-     * Requests are additive but if a sequence of requests totals more than {@code Long.MAX_VALUE} then 
-     * {@code Long.MAX_VALUE} requests will be actioned and the extras <i>may</i> be ignored. Arriving at 
-     * {@code Long.MAX_VALUE} by addition of requests cannot be assumed to disable backpressure. For example, 
+     * Requests are additive but if a sequence of requests totals more than {@code Long.MAX_VALUE} then
+     * {@code Long.MAX_VALUE} requests will be actioned and the extras <i>may</i> be ignored. Arriving at
+     * {@code Long.MAX_VALUE} by addition of requests cannot be assumed to disable backpressure. For example,
      * the code below may result in {@code Long.MAX_VALUE} requests being actioned only.
-     * 
+     *
      * <pre>
      * request(100);
      * request(Long.MAX_VALUE-1);
-     * </pre> 
+     * </pre>
      *
      * @param n the maximum number of items you want this Producer to produce, or {@code Long.MAX_VALUE} if you
      *          want the Producer to produce items at its own pace
diff --git a/src/main/java/rx/Scheduler.java b/src/main/java/rx/Scheduler.java
index 405ceb3373..a868751486 100644
--- a/src/main/java/rx/Scheduler.java
+++ b/src/main/java/rx/Scheduler.java
@@ -145,7 +145,7 @@ public void call() {
                         if (nowNanos + CLOCK_DRIFT_TOLERANCE_NANOS < lastNowNanos
                                 || nowNanos >= lastNowNanos + periodInNanos + CLOCK_DRIFT_TOLERANCE_NANOS) {
                             nextTick = nowNanos + periodInNanos;
-                            /* 
+                            /*
                              * Shift the start point back by the drift as if the whole thing
                              * started count periods ago.
                              */
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 47d6208543..99e7522451 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -1,11 +1,11 @@
 /**
  * Copyright 2015 Netflix, Inc.
- * 
+ *
  * 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.
@@ -44,7 +44,7 @@
  * <p>
  * For more information see the <a href="http://reactivex.io/documentation/observable.html">ReactiveX
  * documentation</a>.
- * 
+ *
  * @param <T>
  *            the type of the item emitted by the Single
  * @since (If this class graduates from "Experimental" replace this parenthetical with the release number)
@@ -59,7 +59,7 @@ public class Single<T> {
      * <p>
      * <em>Note:</em> Use {@link #create(OnSubscribe)} to create a Single, instead of this constructor,
      * unless you specifically have a need for inheritance.
-     * 
+     *
      * @param f
      *            {@code OnExecute} to be executed when {@code execute(SingleSubscriber)} or
      *            {@code subscribe(Subscriber)} is called
@@ -114,7 +114,7 @@ private Single(final Observable.OnSubscribe<T> f) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T>
      *            the type of the item that this Single emits
      * @param f
@@ -151,7 +151,7 @@ public interface OnSubscribe<T> extends Action1<SingleSubscriber<? super T>> {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code lift} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the downstream's value type (output)
      * @param lift
      *            the Operator that implements the Single-operating function to be applied to the source Single
@@ -197,7 +197,7 @@ public void call(Subscriber<? super R> o) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code compose} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the value type of the single returned by the transformer function
      * @param transformer
      *            implements the function that transforms the source Single
@@ -211,7 +211,7 @@ public <R> Single<R> compose(Transformer<? super T, ? extends R> transformer) {
 
     /**
      * Transformer function used by {@link #compose}.
-     * 
+     *
      * @warn more complete description needed
      * @param <T> the source Single's value type
      * @param <R> the transformed Single's value type
@@ -232,7 +232,7 @@ private static <T> Observable<T> asObservable(Single<T> t) {
 
     /**
      * INTERNAL: Used with lift and operators.
-     * 
+     *
      * Converts the source {@code Single<T>} into an {@code Single<Observable<T>>} that emits an Observable
      * that emits the same emission as the source Single.
      * <p>
@@ -241,7 +241,7 @@ private static <T> Observable<T> asObservable(Single<T> t) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code nest} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return a Single that emits an Observable that emits the same item as the source Single
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
@@ -263,7 +263,7 @@ private Single<Observable<T>> nest() {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be concatenated
@@ -307,7 +307,7 @@ public static <T> Observable<T> concat(Single<? extends T> t1, Single<? extends
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be concatenated
@@ -419,7 +419,7 @@ public static <T> Observable<T> concat(Single<? extends T> t1, Single<? extends
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be concatenated
@@ -452,7 +452,7 @@ public static <T> Observable<T> concat(Single<? extends T> t1, Single<? extends
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be concatenated
@@ -488,7 +488,7 @@ public static <T> Observable<T> concat(Single<? extends T> t1, Single<? extends
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code error} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param exception
      *            the particular Throwable to pass to {@link SingleSubscriber#onError onError}
      * @param <T>
@@ -522,7 +522,7 @@ public void call(SingleSubscriber<? super T> te) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code from} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param future
      *            the source {@link Future}
      * @param <T>
@@ -550,7 +550,7 @@ public static <T> Single<T> from(Future<? extends T> future) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code from} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param future
      *            the source {@link Future}
      * @param timeout
@@ -580,7 +580,7 @@ public static <T> Single<T> from(Future<? extends T> future, long timeout, TimeU
      * <dt><b>Scheduler:</b></dt>
      * <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param future
      *            the source {@link Future}
      * @param scheduler
@@ -645,7 +645,7 @@ public void call(SingleSubscriber<? super T> singleSubscriber) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param value
      *            the item to emit
      * @param <T>
@@ -714,7 +714,7 @@ public void onError(Throwable error) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be merged
@@ -738,7 +738,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be merged
@@ -764,7 +764,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be merged
@@ -792,7 +792,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be merged
@@ -822,7 +822,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be merged
@@ -854,7 +854,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be merged
@@ -888,7 +888,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be merged
@@ -924,7 +924,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the common value type
      * @param t1
      *            a Single to be merged
@@ -960,7 +960,7 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the first source Single's value type
      * @param <T2> the second source Single's value type
      * @param <R> the result value type
@@ -993,7 +993,7 @@ public R call(Object... args) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the first source Single's value type
      * @param <T2> the second source Single's value type
      * @param <T3> the third source Single's value type
@@ -1029,7 +1029,7 @@ public R call(Object... args) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the first source Single's value type
      * @param <T2> the second source Single's value type
      * @param <T3> the third source Single's value type
@@ -1068,7 +1068,7 @@ public R call(Object... args) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the first source Single's value type
      * @param <T2> the second source Single's value type
      * @param <T3> the third source Single's value type
@@ -1110,7 +1110,7 @@ public R call(Object... args) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the first source Single's value type
      * @param <T2> the second source Single's value type
      * @param <T3> the third source Single's value type
@@ -1156,7 +1156,7 @@ public R call(Object... args) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the first source Single's value type
      * @param <T2> the second source Single's value type
      * @param <T3> the third source Single's value type
@@ -1205,7 +1205,7 @@ public R call(Object... args) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the first source Single's value type
      * @param <T2> the second source Single's value type
      * @param <T3> the third source Single's value type
@@ -1257,7 +1257,7 @@ public R call(Object... args) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code zip} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T1> the first source Single's value type
      * @param <T2> the second source Single's value type
      * @param <T3> the third source Single's value type
@@ -1341,7 +1341,7 @@ public static <R> Single<R> zip(Iterable<? extends Single<?>> singles, FuncN<? e
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code concat} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            a Single to be concatenated after the current
      * @return an Observable that emits the item emitted by the source Single, followed by the item emitted by
@@ -1361,7 +1361,7 @@ public final Observable<T> concatWith(Single<? extends T> t1) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the result value type
      * @param func
      *            a function that, when applied to the item emitted by the source Single, returns a Single
@@ -1384,7 +1384,7 @@ public final <R> Single<R> flatMap(final Func1<? super T, ? extends Single<? ext
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code flatMapObservable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <R> the result value type
      * @param func
      *            a function that, when applied to the item emitted by the source Single, returns an
@@ -1450,7 +1450,7 @@ public final <R> Single<R> map(Func1<? super T, ? extends R> func) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code mergeWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param t1
      *            a Single to be merged
      * @return an Observable that emits all of the items emitted by the source Singles
@@ -1469,7 +1469,7 @@ public final Observable<T> mergeWith(Single<? extends T> t1) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param scheduler
      *            the {@link Scheduler} to notify subscribers on
      * @return the source Single modified so that its subscribers are notified on the specified
@@ -1482,7 +1482,7 @@ public final Single<T> observeOn(Scheduler scheduler) {
         if (this instanceof ScalarSynchronousSingle) {
             return ((ScalarSynchronousSingle<T>)this).scalarScheduleOn(scheduler);
         }
-        // Note that since Single emits onSuccess xor onError, 
+        // Note that since Single emits onSuccess xor onError,
         // there is no cut-ahead possible like with regular Observable sequences.
         return lift(new OperatorObserveOn<T>(scheduler, false));
     }
@@ -1506,7 +1506,7 @@ public final Single<T> observeOn(Scheduler scheduler) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code onErrorReturn} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param resumeFunction
      *            a function that returns an item that the new Single will emit if the source Single encounters
      *            an error
@@ -1592,7 +1592,7 @@ public final Single<T> onErrorResumeNext(final Func1<Throwable, ? extends Single
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @return a {@link Subscription} reference can request the {@link Single} stop work.
      * @throws OnErrorNotImplementedException
      *             if the Single tries to call {@link Subscriber#onError}
@@ -1625,7 +1625,7 @@ public final void onNext(T args) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onSuccess
      *            the {@code Action1<T>} you have designed to accept the emission from the Single
      * @return a {@link Subscription} reference can request the {@link Single} stop work.
@@ -1667,7 +1667,7 @@ public final void onNext(T args) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param onSuccess
      *            the {@code Action1<T>} you have designed to accept the emission from the Single
      * @param onError
@@ -1717,7 +1717,7 @@ public final void onNext(T args) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code unsafeSubscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param subscriber
      *            the Subscriber that will handle the emission or notification from the Single
      * @return the subscription that allows unsubscribing
@@ -1742,7 +1742,7 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
                 // TODO could the hook be the cause of the error in the on error handling.
                 RxJavaHooks.onSingleError(r);
                 // TODO why aren't we throwing the hook's return value.
-                throw r; // NOPMD 
+                throw r; // NOPMD
             }
             return Subscriptions.unsubscribed();
         }
@@ -1751,9 +1751,9 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
     /**
      * Subscribes an Observer to this single and returns a Subscription that allows
      * unsubscription.
-     * 
+     *
      * @param observer the Observer to subscribe
-     * @return the Subscription that allows unsubscription 
+     * @return the Subscription that allows unsubscription
      */
     public final Subscription subscribe(final Observer<? super T> observer) {
         if (observer == null) {
@@ -1771,7 +1771,7 @@ public void onError(Throwable error) {
             }
         });
     }
-    
+
     /**
      * Subscribes to a Single and provides a Subscriber that implements functions to handle the item the Single
      * emits or any error notification it issues.
@@ -1793,7 +1793,7 @@ public void onError(Throwable error) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param subscriber
      *            the {@link Subscriber} that will handle the emission or notification from the Single
      * @return a {@link Subscription} reference can request the {@link Single} stop work.
@@ -1852,7 +1852,7 @@ public final Subscription subscribe(Subscriber<? super T> subscriber) {
                 // TODO could the hook be the cause of the error in the on error handling.
                 RxJavaHooks.onSingleError(r);
                 // TODO why aren't we throwing the hook's return value.
-                throw r; // NOPMD 
+                throw r; // NOPMD
             }
             return Subscriptions.empty();
         }
@@ -1879,7 +1879,7 @@ public final Subscription subscribe(Subscriber<? super T> subscriber) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code subscribe} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param te
      *            the {@link SingleSubscriber} that will handle the emission or notification from the Single
      * @return a {@link Subscription} reference can request the {@link Single} stop work.
@@ -1925,7 +1925,7 @@ public void onNext(T t) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param scheduler
      *            the {@link Scheduler} to perform subscription actions on
      * @return the source Single modified so that its subscriptions happen on the specified {@link Scheduler}
@@ -2210,12 +2210,12 @@ public void onError(Throwable e) {
     public final <R> R to(Func1<? super Single<T>, R> converter) {
         return converter.call(this);
     }
-    
+
     /**
      * Converts this Single into an {@link Observable}.
      * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Single.toObservable.png" alt="">
-     * 
+     *
      * @return an {@link Observable} that emits a single item T.
      */
     public final Observable<T> toObservable() {
@@ -2256,7 +2256,7 @@ public final Completable toCompletable() {
      * <dt><b>Scheduler:</b></dt>
      * <dd>This version of {@code timeout} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            maximum duration before the Single times out
      * @param timeUnit
@@ -2279,7 +2279,7 @@ public final Single<T> timeout(long timeout, TimeUnit timeUnit) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            maximum duration before the Single times out
      * @param timeUnit
@@ -2304,7 +2304,7 @@ public final Single<T> timeout(long timeout, TimeUnit timeUnit, Scheduler schedu
      * <dt><b>Scheduler:</b></dt>
      * <dd>This version of {@code timeout} operates by default on the {@code computation} {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            maximum time before a timeout occurs
      * @param timeUnit
@@ -2328,7 +2328,7 @@ public final Single<T> timeout(long timeout, TimeUnit timeUnit, Single<? extends
      * <dt><b>Scheduler:</b></dt>
      * <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     * 
+     *
      * @param timeout
      *            maximum duration before a timeout occurs
      * @param timeUnit
@@ -2371,7 +2371,7 @@ public final BlockingSingle<T> toBlocking() {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code zipWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T2>
      *            the type of items emitted by the {@code other} Single
      * @param <R>
@@ -2455,7 +2455,7 @@ public void call(final Throwable throwable) {
             }
         }));
     }
-    
+
     /**
      * Modifies the source {@link Single} so that it invokes an action when it calls {@code onSuccess}.
      * <p>
@@ -2759,13 +2759,13 @@ public final Single<T> retry(Func2<Integer, Throwable, Boolean> predicate) {
      * Returns a Single that emits the same values as the source Single with the exception of an
      * {@code onError}. An {@code onError} notification from the source will result in the emission of a
      * {@link Throwable} item to the Observable provided as an argument to the {@code notificationHandler}
-     * function. 
+     * function.
      * <p>Emissions from the handler {@code Observable} is treated as follows:
      * <ul>
      * <li>If the handler {@code Observable} emits an {@code onCompleted} the {@code retryWhen} will call {@code onError}
-     * with {@code NoSuchElementException} on the child subscription.</li> 
+     * with {@code NoSuchElementException} on the child subscription.</li>
      * <li>If the handler {@code Observable} emits an {@code onError} the {@code retryWhen} will call
-     * {@code onError} with the same Throwable instance on the child subscription. 
+     * {@code onError} with the same Throwable instance on the child subscription.
      * <li>Otherwise, the operator will resubscribe to the source Single.</li>
      * </ul>
      * <p>The {@code notificationHandler} function is called for each subscriber individually. This allows per-Subscriber
@@ -2780,7 +2780,7 @@ public final Single<T> retry(Func2<Integer, Throwable, Boolean> predicate) {
      * Note that you must compose over the input {@code Observable} provided in the function call because {@retryWhen} expects
      * an emission of the exception to be matched by an event from the handler Observable.
      * <p>
-     * 
+     *
      * <img width="640" height="430" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/retryWhen.f.png" alt="">
      *
      * <dl>
@@ -2807,7 +2807,7 @@ public final Single<T> retryWhen(final Func1<Observable<? extends Throwable>, ?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code using} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the value type of the generated source
      * @param <Resource> the type of the per-subscriber resource
      * @param resourceFactory
@@ -2826,9 +2826,9 @@ public static <T, Resource> Single<T> using(
             final Action1<? super Resource> disposeAction) {
         return using(resourceFactory, singleFactory, disposeAction, false);
     }
-    
+
     /**
-     * Constructs a Single that creates a dependent resource object which is disposed of just before 
+     * Constructs a Single that creates a dependent resource object which is disposed of just before
      * termination if you have set {@code disposeEagerly} to {@code true} and unsubscription does not occur
      * before termination. Otherwise resource disposal will occur on unsubscription.  Eager disposal is
      * particularly appropriate for a synchronous Single that reuses resources. {@code disposeAction} will
@@ -2839,7 +2839,7 @@ public static <T, Resource> Single<T> using(
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code using} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <T> the value type of the generated source
      * @param <Resource> the type of the per-subscriber resource
      * @param resourceFactory
@@ -2849,7 +2849,7 @@ public static <T, Resource> Single<T> using(
      * @param disposeAction
      *            the function that will dispose of the resource
      * @param disposeEagerly
-     *            if {@code true} then disposal will happen either on unsubscription or just before emission of 
+     *            if {@code true} then disposal will happen either on unsubscription or just before emission of
      *            a terminal event ({@code onComplete} or {@code onError}).
      * @return the Single whose lifetime controls the lifetime of the dependent resource object
      * @see <a href="http://reactivex.io/documentation/operators/using.html">ReactiveX operators documentation: Using</a>
diff --git a/src/main/java/rx/SingleSubscriber.java b/src/main/java/rx/SingleSubscriber.java
index 7ab135e8ab..b9e4f6739a 100644
--- a/src/main/java/rx/SingleSubscriber.java
+++ b/src/main/java/rx/SingleSubscriber.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2015 Netflix, Inc.
- * 
+ *
  * 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.
@@ -25,7 +25,7 @@
  * {@code Single} calls the SingleSubscriber's {@link #onSuccess} and {@link #onError} methods to provide
  * notifications. A well-behaved {@code Single} will call a SingleSubscriber's {@link #onSuccess} method exactly
  * once or the SingleSubscriber's {@link #onError} method exactly once.
- * 
+ *
  * @see <a href="http://reactivex.io/documentation/observable.html">ReactiveX documentation: Observable</a>
  * @param <T>
  *          the type of item the SingleSubscriber expects to observe
@@ -35,13 +35,13 @@
 public abstract class SingleSubscriber<T> implements Subscription {
 
     private final SubscriptionList cs = new SubscriptionList();
-    
+
     /**
      * Notifies the SingleSubscriber with a single item and that the {@link Single} has finished sending
      * push-based notifications.
      * <p>
      * The {@link Single} will not call this method if it calls {@link #onError}.
-     * 
+     *
      * @param value
      *          the item emitted by the Single
      */
@@ -51,12 +51,12 @@ public abstract class SingleSubscriber<T> implements Subscription {
      * Notifies the SingleSubscriber that the {@link Single} has experienced an error condition.
      * <p>
      * If the {@link Single} calls this method, it will not thereafter call {@link #onSuccess}.
-     * 
+     *
      * @param error
      *          the exception encountered by the Single
      */
     public abstract void onError(Throwable error);
-    
+
     /**
      * Adds a {@link Subscription} to this Subscriber's list of subscriptions if this list is not marked as
      * unsubscribed. If the list <em>is</em> marked as unsubscribed, {@code add} will indicate this by
@@ -76,7 +76,7 @@ public final void unsubscribe() {
 
     /**
      * Indicates whether this Subscriber has unsubscribed from its list of subscriptions.
-     * 
+     *
      * @return {@code true} if this Subscriber has unsubscribed from its subscriptions, {@code false} otherwise
      */
     @Override
diff --git a/src/main/java/rx/Subscriber.java b/src/main/java/rx/Subscriber.java
index 3b8913a9f0..1a43864b89 100644
--- a/src/main/java/rx/Subscriber.java
+++ b/src/main/java/rx/Subscriber.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -25,13 +25,13 @@
  * {@link Observable} calls the Subscriber's {@link #onNext} method to emit items. A well-behaved
  * {@link Observable} will call a Subscriber's {@link #onCompleted} method exactly once or the Subscriber's
  * {@link #onError} method exactly once.
- * 
+ *
  * @see <a href="http://reactivex.io/documentation/observable.html">ReactiveX documentation: Observable</a>
  * @param <T>
  *          the type of items the Subscriber expects to observe
  */
 public abstract class Subscriber<T> implements Observer<T>, Subscription {
-    
+
     // represents requested not set yet
     private static final long NOT_SET = Long.MIN_VALUE;
 
@@ -50,7 +50,7 @@ protected Subscriber() {
      * Construct a Subscriber by using another Subscriber for backpressure and
      * for holding the subscription list (when <code>this.add(sub)</code> is
      * called this will in fact call <code>subscriber.add(sub)</code>).
-     * 
+     *
      * @param subscriber
      *            the other Subscriber
      */
@@ -68,7 +68,7 @@ protected Subscriber(Subscriber<?> subscriber) {
      * To retain the chaining of subscribers when setting
      * <code>shareSubscriptions</code> to <code>false</code>, add the created
      * instance to {@code subscriber} via {@link #add}.
-     * 
+     *
      * @param subscriber
      *            the other Subscriber
      * @param shareSubscriptions
@@ -100,7 +100,7 @@ public final void unsubscribe() {
 
     /**
      * Indicates whether this Subscriber has unsubscribed from its list of subscriptions.
-     * 
+     *
      * @return {@code true} if this Subscriber has unsubscribed from its subscriptions, {@code false} otherwise
      */
     @Override
@@ -116,22 +116,22 @@ public final boolean isUnsubscribed() {
     public void onStart() {
         // do nothing by default
     }
-    
+
     /**
      * Request a certain maximum number of emitted items from the Observable this Subscriber is subscribed to.
      * This is a way of requesting backpressure. To disable backpressure, pass {@code Long.MAX_VALUE} to this
      * method.
      * <p>
-     * Requests are additive but if a sequence of requests totals more than {@code Long.MAX_VALUE} then 
-     * {@code Long.MAX_VALUE} requests will be actioned and the extras <i>may</i> be ignored. Arriving at 
-     * {@code Long.MAX_VALUE} by addition of requests cannot be assumed to disable backpressure. For example, 
+     * Requests are additive but if a sequence of requests totals more than {@code Long.MAX_VALUE} then
+     * {@code Long.MAX_VALUE} requests will be actioned and the extras <i>may</i> be ignored. Arriving at
+     * {@code Long.MAX_VALUE} by addition of requests cannot be assumed to disable backpressure. For example,
      * the code below may result in {@code Long.MAX_VALUE} requests being actioned only.
-     * 
+     *
      * <pre>
      * request(100);
      * request(Long.MAX_VALUE-1);
      * </pre>
-     * 
+     *
      * @param n the maximum number of items you want the Observable to emit to the Subscriber at this time, or
      *           {@code Long.MAX_VALUE} if you want the Observable to emit items at its own pace
      * @throws IllegalArgumentException
@@ -140,8 +140,8 @@ public void onStart() {
     protected final void request(long n) {
         if (n < 0) {
             throw new IllegalArgumentException("number requested cannot be negative: " + n);
-        } 
-        
+        }
+
         // if producer is set then we will request from it
         // otherwise we increase the requested count by n
         Producer producerToRequestFrom = null;
@@ -160,7 +160,7 @@ protected final void request(long n) {
     private void addToRequested(long n) {
         if (requested == NOT_SET) {
             requested = n;
-        } else { 
+        } else {
             final long total = requested + n;
             // check if overflow occurred
             if (total < 0) {
@@ -170,7 +170,7 @@ private void addToRequested(long n) {
             }
         }
     }
-    
+
     /**
      * If other subscriber is set (by calling constructor
      * {@link #Subscriber(Subscriber)} or
@@ -181,7 +181,7 @@ private void addToRequested(long n) {
      * is not set and some requests have been made to this subscriber then
      * <code>p.request(n)</code> is called where n is the accumulated requests
      * to this subscriber.
-     * 
+     *
      * @param p
      *            producer to be used by this subscriber or the other subscriber
      *            (or recursively its other subscriber) to make requests from
diff --git a/src/main/java/rx/Subscription.java b/src/main/java/rx/Subscription.java
index 00358903c4..0a5e7f0408 100644
--- a/src/main/java/rx/Subscription.java
+++ b/src/main/java/rx/Subscription.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/annotations/Beta.java b/src/main/java/rx/annotations/Beta.java
index 0a117d6d84..f03bdc40ac 100644
--- a/src/main/java/rx/annotations/Beta.java
+++ b/src/main/java/rx/annotations/Beta.java
@@ -2,19 +2,19 @@
 
 /*
  * Copyright (C) 2010 The Guava Authors
- * 
+ *
  * 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.
- * 
+ *
  * Originally from https://code.google.com/p/guava-libraries/source/browse/guava/src/com/google/common/annotations/Beta.java
  */
 
diff --git a/src/main/java/rx/annotations/Experimental.java b/src/main/java/rx/annotations/Experimental.java
index 52619a56a7..bc9a6bc259 100644
--- a/src/main/java/rx/annotations/Experimental.java
+++ b/src/main/java/rx/annotations/Experimental.java
@@ -4,15 +4,15 @@
  * 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.
- * 
+ *
  * Inspired from https://code.google.com/p/guava-libraries/source/browse/guava/src/com/google/common/annotations/Beta.java
  */
 
@@ -24,9 +24,9 @@
 
 /**
  * Signifies that a public API (public class, method or field) is will almost certainly
- * be changed or removed in a future release. An API bearing this annotation should not 
+ * be changed or removed in a future release. An API bearing this annotation should not
  * be used or relied upon in production code. APIs exposed with this annotation exist
- * to allow broad testing and feedback on experimental features.  
+ * to allow broad testing and feedback on experimental features.
  **/
 @Retention(RetentionPolicy.CLASS)
 @Target({
diff --git a/src/main/java/rx/exceptions/AssemblyStackTraceException.java b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
index 110fc803c8..5fee891344 100644
--- a/src/main/java/rx/exceptions/AssemblyStackTraceException.java
+++ b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -39,23 +39,23 @@ public AssemblyStackTraceException(String message) {
     }
 
     @Override
-    public synchronized Throwable fillInStackTrace() { // NOPMD 
+    public synchronized Throwable fillInStackTrace() { // NOPMD
         return this;
     }
-    
+
     /**
      * Finds an empty cause slot and assigns itself to it.
      * @param exception the exception to start from
      */
     public void attachTo(Throwable exception) {
         Set<Throwable> memory = new HashSet<Throwable>();
-        
+
         for (;;) {
             if (exception.getCause() == null) {
                 exception.initCause(this);
                 return;
             }
-            
+
             exception = exception.getCause();
             if (!memory.add(exception)) {
                 // in case we run into a cycle, give up and report this to the hooks
@@ -64,12 +64,12 @@ public void attachTo(Throwable exception) {
             }
         }
     }
-    
+
     /**
      * Locate the first AssemblyStackTraceException in the causal chain of the
      * given Throwable (or it if it's one).
-     * @param e the input throwable 
-     * @return the AssemblyStackTraceException located or null if not found 
+     * @param e the input throwable
+     * @return the AssemblyStackTraceException located or null if not found
      */
     public static AssemblyStackTraceException find(Throwable e) {
         Set<Throwable> memory = new HashSet<Throwable>();
diff --git a/src/main/java/rx/exceptions/CompositeException.java b/src/main/java/rx/exceptions/CompositeException.java
index d4af4c5350..154ce4ed6a 100644
--- a/src/main/java/rx/exceptions/CompositeException.java
+++ b/src/main/java/rx/exceptions/CompositeException.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -27,10 +27,10 @@
  *
  * Its invariant is to contain an immutable, ordered (by insertion order), unique list of non-composite
  * exceptions. You can retrieve individual exceptions in this list with {@link #getExceptions()}.
- * 
+ *
  * The {@link #printStackTrace()} implementation handles the StackTrace in a customized way instead of using
  * {@code getCause()} so that it can avoid circular references.
- * 
+ *
  * If you invoke {@link #getCause()}, it will lazily create the causal chain but will stop if it finds any
  * Throwable in the chain that it has already seen.
  */
@@ -43,20 +43,20 @@ public final class CompositeException extends RuntimeException {
 
     private Throwable cause;
 
-    /** 
+    /**
      * Constructs a CompositeException with the given prefix and error collection.
      * @param messagePrefix the prefix to use (actually unused)
      * @param errors the collection of errors
      * @deprecated please use {@link #CompositeException(Collection)} */
     @Deprecated
-    public CompositeException(String messagePrefix, Collection<? extends Throwable> errors) { // NOPMD 
+    public CompositeException(String messagePrefix, Collection<? extends Throwable> errors) { // NOPMD
         Set<Throwable> deDupedExceptions = new LinkedHashSet<Throwable>();
         List<Throwable> localExceptions = new ArrayList<Throwable>();
         if (errors != null) {
             for (Throwable ex : errors) {
                 if (ex instanceof CompositeException) {
                     deDupedExceptions.addAll(((CompositeException) ex).getExceptions());
-                } else 
+                } else
                 if (ex != null) {
                     deDupedExceptions.add(ex);
                 } else {
@@ -88,7 +88,7 @@ public CompositeException(Throwable... errors) {
             for (Throwable ex : errors) {
                 if (ex instanceof CompositeException) {
                     deDupedExceptions.addAll(((CompositeException) ex).getExceptions());
-                } else 
+                } else
                 if (ex != null) {
                     deDupedExceptions.add(ex);
                 } else {
@@ -119,7 +119,7 @@ public String getMessage() {
     }
 
     @Override
-    public synchronized Throwable getCause() { // NOPMD 
+    public synchronized Throwable getCause() { // NOPMD
         if (cause == null) {
             // we lazily generate this causal chain if this is called
             CompositeExceptionCausalChain localCause = new CompositeExceptionCausalChain();
@@ -132,7 +132,7 @@ public synchronized Throwable getCause() { // NOPMD
                     continue;
                 }
                 seenCauses.add(e);
-                
+
                 List<Throwable> listOfCauses = getListOfCauses(e);
                 // check if any of them have been seen before
                 for(Throwable child : listOfCauses) {
@@ -147,7 +147,7 @@ public synchronized Throwable getCause() { // NOPMD
                 // we now have 'e' as the last in the chain
                 try {
                     chain.initCause(e);
-                } catch (Throwable t) { // NOPMD 
+                } catch (Throwable t) { // NOPMD
                     // ignore
                     // the javadocs say that some Throwables (depending on how they're made) will never
                     // let me call initCause without blowing up even if it returns null
@@ -187,7 +187,7 @@ public void printStackTrace(PrintWriter s) {
     /**
      * Special handling for printing out a {@code CompositeException}.
      * Loops through all inner exceptions and prints them out.
-     * 
+     *
      * @param s
      *            stream to print to
      */
diff --git a/src/main/java/rx/exceptions/Exceptions.java b/src/main/java/rx/exceptions/Exceptions.java
index d82015581a..d20212cb0a 100644
--- a/src/main/java/rx/exceptions/Exceptions.java
+++ b/src/main/java/rx/exceptions/Exceptions.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -44,9 +44,9 @@ private Exceptions() {
     public static RuntimeException propagate(Throwable t) {
         /*
          * The return type of RuntimeException is a trick for code to be like this:
-         * 
+         *
          * throw Exceptions.propagate(e);
-         * 
+         *
          * Even though nothing will return and throw via that 'throw', it allows the code to look like it
          * so it's easy to read and understand that it will always result in a throw.
          */
@@ -55,7 +55,7 @@ public static RuntimeException propagate(Throwable t) {
         } else if (t instanceof Error) {
             throw (Error) t;
         } else {
-            throw new RuntimeException(t); // NOPMD 
+            throw new RuntimeException(t); // NOPMD
         }
     }
     /**
@@ -124,7 +124,7 @@ public static void addCause(Throwable e, Throwable cause) {
         // we now have 'e' as the last in the chain
         try {
             e.initCause(cause);
-        } catch (Throwable t) { // NOPMD 
+        } catch (Throwable t) { // NOPMD
             // ignore
             // the javadocs say that some Throwables (depending on how they're made) will never
             // let me call initCause without blowing up even if it returns null
@@ -162,20 +162,20 @@ public static void throwIfAny(List<? extends Throwable> exceptions) {
         if (exceptions != null && !exceptions.isEmpty()) {
             if (exceptions.size() == 1) {
                 Throwable t = exceptions.get(0);
-                // had to manually inline propagate because some tests attempt StackOverflowError 
+                // had to manually inline propagate because some tests attempt StackOverflowError
                 // and can't handle it with the stack space remaining
                 if (t instanceof RuntimeException) {
                     throw (RuntimeException) t;
                 } else if (t instanceof Error) {
                     throw (Error) t;
                 } else {
-                    throw new RuntimeException(t); // NOPMD 
+                    throw new RuntimeException(t); // NOPMD
                 }
             }
             throw new CompositeException(exceptions);
         }
     }
-    
+
     /**
      * Forwards a fatal exception or reports it along with the value
      * caused it to the given Observer.
diff --git a/src/main/java/rx/exceptions/MissingBackpressureException.java b/src/main/java/rx/exceptions/MissingBackpressureException.java
index 3c11bc42d4..221b628bb1 100644
--- a/src/main/java/rx/exceptions/MissingBackpressureException.java
+++ b/src/main/java/rx/exceptions/MissingBackpressureException.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/exceptions/OnCompletedFailedException.java b/src/main/java/rx/exceptions/OnCompletedFailedException.java
index e6ae90c5ff..c474f009eb 100644
--- a/src/main/java/rx/exceptions/OnCompletedFailedException.java
+++ b/src/main/java/rx/exceptions/OnCompletedFailedException.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -33,7 +33,7 @@ public final class OnCompletedFailedException extends RuntimeException {
     public OnCompletedFailedException(Throwable throwable) {
         super(throwable != null ? throwable : new NullPointerException());
     }
-    
+
     /**
      * Customizes the {@code Throwable} with a custom message and wraps it before it is to be re-thrown as an
      * {@code OnCompletedFailedException}.
diff --git a/src/main/java/rx/exceptions/OnErrorFailedException.java b/src/main/java/rx/exceptions/OnErrorFailedException.java
index a79000c21d..8d297c077b 100644
--- a/src/main/java/rx/exceptions/OnErrorFailedException.java
+++ b/src/main/java/rx/exceptions/OnErrorFailedException.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/exceptions/OnErrorNotImplementedException.java b/src/main/java/rx/exceptions/OnErrorNotImplementedException.java
index d707a791fa..1763d912e9 100644
--- a/src/main/java/rx/exceptions/OnErrorNotImplementedException.java
+++ b/src/main/java/rx/exceptions/OnErrorNotImplementedException.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/exceptions/OnErrorThrowable.java b/src/main/java/rx/exceptions/OnErrorThrowable.java
index 5f4ab73e8a..f49a2c8c47 100644
--- a/src/main/java/rx/exceptions/OnErrorThrowable.java
+++ b/src/main/java/rx/exceptions/OnErrorThrowable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -86,7 +86,7 @@ public static OnErrorThrowable from(Throwable t) {
     /**
      * Adds the given item as the final cause of the given {@code Throwable}, wrapped in {@code OnNextValue}
      * (which extends {@code RuntimeException}).
-     * 
+     *
      * @param e
      *          the {@link Throwable} to which you want to add a cause
      * @param value
@@ -119,10 +119,10 @@ public static class OnNextValue extends RuntimeException {
         private static final long serialVersionUID = -3454462756050397899L;
 
         private final Object value;
-        
-        // Lazy loaded singleton 
+
+        // Lazy loaded singleton
         static final class Primitives {
-            
+
             static final Set<Class<?>> INSTANCE = create();
 
             private static Set<Class<?>> create() {
@@ -135,7 +135,7 @@ private static Set<Class<?>> create() {
                 set.add(Long.class);
                 set.add(Float.class);
                 set.add(Double.class);
-                // Void is another primitive but cannot be instantiated 
+                // Void is another primitive but cannot be instantiated
                 // and is caught by the null check in renderValue
                 return set;
             }
diff --git a/src/main/java/rx/exceptions/UnsubscribeFailedException.java b/src/main/java/rx/exceptions/UnsubscribeFailedException.java
index 69eb260ea2..0daba61fd4 100644
--- a/src/main/java/rx/exceptions/UnsubscribeFailedException.java
+++ b/src/main/java/rx/exceptions/UnsubscribeFailedException.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -33,7 +33,7 @@ public final class UnsubscribeFailedException extends RuntimeException {
     public UnsubscribeFailedException(Throwable throwable) {
         super(throwable != null ? throwable : new NullPointerException());
     }
-    
+
     /**
      * Customizes the {@code Throwable} with a custom message and wraps it before it is to be re-thrown as an
      * {@code UnsubscribeFailedException}.
@@ -46,5 +46,5 @@ public UnsubscribeFailedException(Throwable throwable) {
     public UnsubscribeFailedException(String message, Throwable throwable) {
         super(message, throwable != null ? throwable : new NullPointerException());
     }
-    
+
 }
diff --git a/src/main/java/rx/exceptions/package-info.java b/src/main/java/rx/exceptions/package-info.java
index 3cd8ac94dc..613c7416b9 100644
--- a/src/main/java/rx/exceptions/package-info.java
+++ b/src/main/java/rx/exceptions/package-info.java
@@ -15,7 +15,7 @@
  */
 
 /**
- * Exception handling utilities, safe subscriber exception classes, 
+ * Exception handling utilities, safe subscriber exception classes,
  * lifecycle exception classes.
  */
 package rx.exceptions;
\ No newline at end of file
diff --git a/src/main/java/rx/functions/Action.java b/src/main/java/rx/functions/Action.java
index 277533e325..8ea4cbf6be 100644
--- a/src/main/java/rx/functions/Action.java
+++ b/src/main/java/rx/functions/Action.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Action0.java b/src/main/java/rx/functions/Action0.java
index cf11288d28..0c85ef33ca 100644
--- a/src/main/java/rx/functions/Action0.java
+++ b/src/main/java/rx/functions/Action0.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Action1.java b/src/main/java/rx/functions/Action1.java
index ce9da099e7..c2bc25db99 100644
--- a/src/main/java/rx/functions/Action1.java
+++ b/src/main/java/rx/functions/Action1.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Action2.java b/src/main/java/rx/functions/Action2.java
index c46b957f18..75e19ff936 100644
--- a/src/main/java/rx/functions/Action2.java
+++ b/src/main/java/rx/functions/Action2.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Action3.java b/src/main/java/rx/functions/Action3.java
index e961358703..4b195d9965 100644
--- a/src/main/java/rx/functions/Action3.java
+++ b/src/main/java/rx/functions/Action3.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Action4.java b/src/main/java/rx/functions/Action4.java
index 565fc51cbb..93bbdf74d0 100644
--- a/src/main/java/rx/functions/Action4.java
+++ b/src/main/java/rx/functions/Action4.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Action5.java b/src/main/java/rx/functions/Action5.java
index dcc3971c4e..fe8fe5a52f 100644
--- a/src/main/java/rx/functions/Action5.java
+++ b/src/main/java/rx/functions/Action5.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Action6.java b/src/main/java/rx/functions/Action6.java
index 0d298c4ab1..ec4a7eff23 100644
--- a/src/main/java/rx/functions/Action6.java
+++ b/src/main/java/rx/functions/Action6.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Action7.java b/src/main/java/rx/functions/Action7.java
index 513844ae19..5978c18e95 100644
--- a/src/main/java/rx/functions/Action7.java
+++ b/src/main/java/rx/functions/Action7.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Action8.java b/src/main/java/rx/functions/Action8.java
index 97a7424677..3fe35985e5 100644
--- a/src/main/java/rx/functions/Action8.java
+++ b/src/main/java/rx/functions/Action8.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Action9.java b/src/main/java/rx/functions/Action9.java
index c23761c610..1296d14022 100644
--- a/src/main/java/rx/functions/Action9.java
+++ b/src/main/java/rx/functions/Action9.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/ActionN.java b/src/main/java/rx/functions/ActionN.java
index ccc714c341..d669f26ebd 100644
--- a/src/main/java/rx/functions/ActionN.java
+++ b/src/main/java/rx/functions/ActionN.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Actions.java b/src/main/java/rx/functions/Actions.java
index ec15d4152a..31e9826aa4 100644
--- a/src/main/java/rx/functions/Actions.java
+++ b/src/main/java/rx/functions/Actions.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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
@@ -99,10 +99,10 @@ public void call(Object... args) {
             // deliberately no op
         }
     }
-    
+
     /**
      * Converts an {@link Action0} to a function that calls the action and returns {@code null}.
-     * 
+     *
      * @param action
      *            the {@link Action0} to convert
      * @return a {@link Func0} that calls {@code action} and returns {@code null}
@@ -113,7 +113,7 @@ public static Func0<Void> toFunc(final Action0 action) {
 
     /**
      * Converts an {@link Action1} to a function that calls the action and returns {@code null}.
-     * 
+     *
      * @param <T1> the first argument type
      * @param action
      *            the {@link Action1} to convert
@@ -125,7 +125,7 @@ public static <T1> Func1<T1, Void> toFunc(final Action1<T1> action) {
 
     /**
      * Converts an {@link Action2} to a function that calls the action and returns {@code null}.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param action
@@ -138,7 +138,7 @@ public static <T1, T2> Func2<T1, T2, Void> toFunc(final Action2<T1, T2> action)
 
     /**
      * Converts an {@link Action3} to a function that calls the action and returns {@code null}.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -152,7 +152,7 @@ public static <T1, T2, T3> Func3<T1, T2, T3, Void> toFunc(final Action3<T1, T2,
 
     /**
      * Converts an {@link Action4} to a function that calls the action and returns {@code null}.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -167,7 +167,7 @@ public static <T1, T2, T3, T4> Func4<T1, T2, T3, T4, Void> toFunc(final Action4<
 
     /**
      * Converts an {@link Action5} to a function that calls the action and returns {@code null}.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -184,7 +184,7 @@ public static <T1, T2, T3, T4, T5> Func5<T1, T2, T3, T4, T5, Void> toFunc(
 
     /**
      * Converts an {@link Action6} to a function that calls the action and returns {@code null}.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -202,7 +202,7 @@ public static <T1, T2, T3, T4, T5, T6> Func6<T1, T2, T3, T4, T5, T6, Void> toFun
 
     /**
      * Converts an {@link Action7} to a function that calls the action and returns {@code null}.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -221,7 +221,7 @@ public static <T1, T2, T3, T4, T5, T6, T7> Func7<T1, T2, T3, T4, T5, T6, T7, Voi
 
     /**
      * Converts an {@link Action8} to a function that calls the action and returns {@code null}.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -241,7 +241,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> Func8<T1, T2, T3, T4, T5, T6, T7,
 
     /**
      * Converts an {@link Action9} to a function that calls the action and returns {@code null}.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -262,7 +262,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9> Func9<T1, T2, T3, T4, T5, T6,
 
     /**
      * Converts an {@link ActionN} to a function that calls the action and returns {@code null}.
-     * 
+     *
      * @param action
      *            the {@link ActionN} to convert
      * @return a {@link FuncN} that calls {@code action} and returns {@code null}
@@ -274,7 +274,7 @@ public static FuncN<Void> toFunc(
 
     /**
      * Converts an {@link Action0} to a function that calls the action and returns a specified value.
-     * 
+     *
      * @param <R> the result type
      * @param action
      *            the {@link Action0} to convert
@@ -294,7 +294,7 @@ public R call() {
 
     /**
      * Converts an {@link Action1} to a function that calls the action and returns a specified value.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <R> the result type
      * @param action
@@ -315,7 +315,7 @@ public R call(T1 t1) {
 
     /**
      * Converts an {@link Action2} to a function that calls the action and returns a specified value.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <R> the result type
@@ -337,7 +337,7 @@ public R call(T1 t1, T2 t2) {
 
     /**
      * Converts an {@link Action3} to a function that calls the action and returns a specified value.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -360,7 +360,7 @@ public R call(T1 t1, T2 t2, T3 t3) {
 
     /**
      * Converts an {@link Action4} to a function that calls the action and returns a specified value.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -384,7 +384,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4) {
 
     /**
      * Converts an {@link Action5} to a function that calls the action and returns a specified value.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -410,7 +410,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
 
     /**
      * Converts an {@link Action6} to a function that calls the action and returns a specified value.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -437,7 +437,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) {
 
     /**
      * Converts an {@link Action7} to a function that calls the action and returns a specified value.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -465,7 +465,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) {
 
     /**
      * Converts an {@link Action8} to a function that calls the action and returns a specified value.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -494,7 +494,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) {
 
     /**
      * Converts an {@link Action9} to a function that calls the action and returns a specified value.
-     * 
+     *
      * @param <T1> the first argument type
      * @param <T2> the second argument type
      * @param <T3> the third argument type
@@ -524,7 +524,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9) {
 
     /**
      * Converts an {@link ActionN} to a function that calls the action and returns a specified value.
-     * 
+     *
      * @param <R> the result type
      * @param action
      *            the {@link ActionN} to convert
@@ -542,7 +542,7 @@ public R call(Object... args) {
             }
         };
     }
-    
+
     /**
      * Wraps an Action0 instance into an Action1 instance where the latter calls
      * the former.
@@ -553,14 +553,14 @@ public R call(Object... args) {
     public static <T> Action1<T> toAction1(Action0 action) {
         return new Action1CallsAction0<T>(action);
     }
-    
+
     static final class Action1CallsAction0<T> implements Action1<T> {
         final Action0 action;
-        
+
         public Action1CallsAction0(Action0 action) {
             this.action = action;
         }
-        
+
         @Override
         public void call(T t) {
             action.call();
diff --git a/src/main/java/rx/functions/Func0.java b/src/main/java/rx/functions/Func0.java
index fc9e10981b..b0179bce90 100644
--- a/src/main/java/rx/functions/Func0.java
+++ b/src/main/java/rx/functions/Func0.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Func1.java b/src/main/java/rx/functions/Func1.java
index 64ffae0c60..2edc94d2fe 100644
--- a/src/main/java/rx/functions/Func1.java
+++ b/src/main/java/rx/functions/Func1.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Func2.java b/src/main/java/rx/functions/Func2.java
index 660a11b79c..5222aecdf0 100644
--- a/src/main/java/rx/functions/Func2.java
+++ b/src/main/java/rx/functions/Func2.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Func3.java b/src/main/java/rx/functions/Func3.java
index 0029ceebfb..f3b82bc729 100644
--- a/src/main/java/rx/functions/Func3.java
+++ b/src/main/java/rx/functions/Func3.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Func4.java b/src/main/java/rx/functions/Func4.java
index 0daca118ee..229a5348ba 100644
--- a/src/main/java/rx/functions/Func4.java
+++ b/src/main/java/rx/functions/Func4.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Func5.java b/src/main/java/rx/functions/Func5.java
index 7385065452..2e35bd2fa2 100644
--- a/src/main/java/rx/functions/Func5.java
+++ b/src/main/java/rx/functions/Func5.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Func6.java b/src/main/java/rx/functions/Func6.java
index 9a8e2a436b..32c10b64d2 100644
--- a/src/main/java/rx/functions/Func6.java
+++ b/src/main/java/rx/functions/Func6.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Func7.java b/src/main/java/rx/functions/Func7.java
index 79d23a829d..bc92638242 100644
--- a/src/main/java/rx/functions/Func7.java
+++ b/src/main/java/rx/functions/Func7.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Func8.java b/src/main/java/rx/functions/Func8.java
index 5e0e31c9c9..2ba2894f86 100644
--- a/src/main/java/rx/functions/Func8.java
+++ b/src/main/java/rx/functions/Func8.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Func9.java b/src/main/java/rx/functions/Func9.java
index 0e8e090cbf..8e0c449f1d 100644
--- a/src/main/java/rx/functions/Func9.java
+++ b/src/main/java/rx/functions/Func9.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/FuncN.java b/src/main/java/rx/functions/FuncN.java
index e78e57a42d..8854e78a0e 100644
--- a/src/main/java/rx/functions/FuncN.java
+++ b/src/main/java/rx/functions/FuncN.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Function.java b/src/main/java/rx/functions/Function.java
index cbe7bd1a37..8064b79304 100644
--- a/src/main/java/rx/functions/Function.java
+++ b/src/main/java/rx/functions/Function.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/functions/Functions.java b/src/main/java/rx/functions/Functions.java
index 31999f45e7..5beab3ab65 100644
--- a/src/main/java/rx/functions/Functions.java
+++ b/src/main/java/rx/functions/Functions.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -22,7 +22,7 @@ private Functions() {
 
     /**
      * Converts a {@link Func0} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <R> the result type
      * @param f
      *          the {@code Func0} to convert
@@ -44,7 +44,7 @@ public R call(Object... args) {
 
     /**
      * Converts a {@link Func1} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param <R> the result type
      * @param f
@@ -68,7 +68,7 @@ public R call(Object... args) {
 
     /**
      * Converts a {@link Func2} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param <T1> the second argument type
      * @param <R> the result type
@@ -93,7 +93,7 @@ public R call(Object... args) {
 
     /**
      * Converts a {@link Func3} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param <T1> the second argument type
      * @param <T2> the third argument type
@@ -119,7 +119,7 @@ public R call(Object... args) {
 
     /**
      * Converts a {@link Func4} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param <T1> the second argument type
      * @param <T2> the third argument type
@@ -146,7 +146,7 @@ public R call(Object... args) {
 
     /**
      * Converts a {@link Func5} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param <T1> the second argument type
      * @param <T2> the third argument type
@@ -174,7 +174,7 @@ public R call(Object... args) {
 
     /**
      * Converts a {@link Func6} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param <T1> the second argument type
      * @param <T2> the third argument type
@@ -203,7 +203,7 @@ public R call(Object... args) {
 
     /**
      * Converts a {@link Func7} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param <T1> the second argument type
      * @param <T2> the third argument type
@@ -233,7 +233,7 @@ public R call(Object... args) {
 
     /**
      * Converts a {@link Func8} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param <T1> the second argument type
      * @param <T2> the third argument type
@@ -264,7 +264,7 @@ public R call(Object... args) {
 
     /**
      * Converts a {@link Func9} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param <T1> the second argument type
      * @param <T2> the third argument type
@@ -296,7 +296,7 @@ public R call(Object... args) {
 
     /**
      * Converts an {@link Action0} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param f
      *          the {@code Action0} to convert
      * @return a {@link FuncN} representation of {@code f}
@@ -318,7 +318,7 @@ public Void call(Object... args) {
 
     /**
      * Converts an {@link Action1} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param f
      *          the {@code Action1} to convert
@@ -342,7 +342,7 @@ public Void call(Object... args) {
 
     /**
      * Converts an {@link Action2} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param <T1> the second argument type
      * @param f
@@ -367,7 +367,7 @@ public Void call(Object... args) {
 
     /**
      * Converts an {@link Action3} to a {@link FuncN} to allow heterogeneous handling of functions with different arities.
-     * 
+     *
      * @param <T0> the first argument type
      * @param <T1> the second argument type
      * @param <T2> the third argument type
diff --git a/src/main/java/rx/internal/operators/BackpressureUtils.java b/src/main/java/rx/internal/operators/BackpressureUtils.java
index d627ef22b5..7f3cc0123c 100644
--- a/src/main/java/rx/internal/operators/BackpressureUtils.java
+++ b/src/main/java/rx/internal/operators/BackpressureUtils.java
@@ -44,9 +44,9 @@ private BackpressureUtils() {
      * Adds {@code n} to {@code requested} field and returns the value prior to
      * addition once the addition is successful (uses CAS semantics). If
      * overflows then sets {@code requested} field to {@code Long.MAX_VALUE}.
-     * 
+     *
      * @param <T> the type of the target object on which the field updater operates
-     * 
+     *
      * @param requested
      *            atomic field updater for a request count
      * @param object
@@ -72,7 +72,7 @@ public static <T> long getAndAddRequest(AtomicLongFieldUpdater<T> requested, T o
      * Adds {@code n} (not validated) to {@code requested} and returns the value prior to addition once the
      * addition is successful (uses CAS semantics). If overflows then sets
      * {@code requested} field to {@code Long.MAX_VALUE}.
-     * 
+     *
      * @param requested
      *            atomic long that should be updated
      * @param n
@@ -89,7 +89,7 @@ public static long getAndAddRequest(AtomicLong requested, long n) {
             }
         }
     }
-    
+
     /**
      * Multiplies two positive longs and caps the result at Long.MAX_VALUE.
      * @param a the first value
@@ -105,7 +105,7 @@ public static long multiplyCap(long a, long b) {
         }
         return u;
     }
-    
+
     /**
      * Adds two positive longs and caps the result at Long.MAX_VALUE.
      * @param a the first value
@@ -119,13 +119,13 @@ public static long addCap(long a, long b) {
         }
         return u;
     }
-    
+
     /**
      * Signals the completion of the main sequence and switches to post-completion replay mode.
-     * 
+     *
      * <p>
      * Don't modify the queue after calling this method!
-     * 
+     *
      * <p>
      * Post-completion backpressure handles the case when a source produces values based on
      * requests when it is active but more values are available even after its completion.
@@ -137,7 +137,7 @@ public static long addCap(long a, long b) {
      * The algorithm utilizes the most significant bit (bit 63) of a long value (AtomicLong) since
      * request amount only goes up to Long.MAX_VALUE (bits 0-62) and negative values aren't
      * allowed.
-     * 
+     *
      * @param <T> the value type to emit
      * @param requested the holder of current requested amount
      * @param queue the queue holding values to be emitted after completion
@@ -146,10 +146,10 @@ public static long addCap(long a, long b) {
     public static <T> void postCompleteDone(AtomicLong requested, Queue<T> queue, Subscriber<? super T> actual) {
         postCompleteDone(requested, queue, actual, UtilityFunctions.<T>identity());
     }
-    
+
     /**
      * Accumulates requests (validated) and handles the completed mode draining of the queue based on the requests.
-     * 
+     *
      * <p>
      * Post-completion backpressure handles the case when a source produces values based on
      * requests when it is active but more values are available even after its completion.
@@ -157,7 +157,7 @@ public static <T> void postCompleteDone(AtomicLong requested, Queue<T> queue, Su
      * coordinate with the requested amounts. This requires two distinct modes: active and
      * completed. In active mode, requests flow through and the queue is not accessed but
      * in completed mode, requests no-longer reach the upstream but help in draining the queue.
-     * 
+     *
      * @param <T> the value type to emit
      * @param requested the holder of current requested amount
      * @param n the value requested;
@@ -169,14 +169,14 @@ public static <T> void postCompleteDone(AtomicLong requested, Queue<T> queue, Su
     public static <T> boolean postCompleteRequest(AtomicLong requested, long n, Queue<T> queue, Subscriber<? super T> actual) {
         return postCompleteRequest(requested, n, queue, actual, UtilityFunctions.<T>identity());
     }
-    
+
     /**
      * Signals the completion of the main sequence and switches to post-completion replay mode
      * and allows exit transformation on the queued values.
-     * 
+     *
      * <p>
      * Don't modify the queue after calling this method!
-     * 
+     *
      * <p>
      * Post-completion backpressure handles the case when a source produces values based on
      * requests when it is active but more values are available even after its completion.
@@ -188,7 +188,7 @@ public static <T> boolean postCompleteRequest(AtomicLong requested, long n, Queu
      * The algorithm utilizes the most significant bit (bit 63) of a long value (AtomicLong) since
      * request amount only goes up to Long.MAX_VALUE (bits 0-62) and negative values aren't
      * allowed.
-     * 
+     *
      * @param <T> the value type in the queue
      * @param <R> the value type to emit
      * @param requested the holder of current requested amount
@@ -199,17 +199,17 @@ public static <T> boolean postCompleteRequest(AtomicLong requested, long n, Queu
     public static <T, R> void postCompleteDone(AtomicLong requested, Queue<T> queue, Subscriber<? super R> actual, Func1<? super T, ? extends R> exitTransform) {
         for (;;) {
             long r = requested.get();
-            
+
             // switch to completed mode only once
             if ((r & COMPLETED_MASK) != 0L) {
                 return;
             }
-            
+
             //
             long u = r | COMPLETED_MASK;
-            
+
             if (requested.compareAndSet(r, u)) {
-                // if we successfully switched to post-complete mode and there 
+                // if we successfully switched to post-complete mode and there
                 // are requests available start draining the queue
                 if (r != 0L) {
                     // if the switch happened when there was outstanding requests, start draining
@@ -219,11 +219,11 @@ public static <T, R> void postCompleteDone(AtomicLong requested, Queue<T> queue,
             }
         }
     }
-    
+
     /**
      * Accumulates requests (validated) and handles the completed mode draining of the queue based on the requests
      * and allows exit transformation on the queued values.
-     * 
+     *
      * <p>
      * Post-completion backpressure handles the case when a source produces values based on
      * requests when it is active but more values are available even after its completion.
@@ -231,7 +231,7 @@ public static <T, R> void postCompleteDone(AtomicLong requested, Queue<T> queue,
      * coordinate with the requested amounts. This requires two distinct modes: active and
      * completed. In active mode, requests flow through and the queue is not accessed but
      * in completed mode, requests no-longer reach the upstream but help in draining the queue.
-     * 
+     *
      * @param <T> the value type in the queue
      * @param <R> the value type to emit
      * @param requested the holder of current requested amount
@@ -249,22 +249,22 @@ public static <T, R> boolean postCompleteRequest(AtomicLong requested, long n, Q
         if (n == 0) {
             return (requested.get() & COMPLETED_MASK) == 0;
         }
-        
+
         for (;;) {
             long r = requested.get();
-            
+
             // mask of the completed flag
             long c = r & COMPLETED_MASK;
             // mask of the requested amount
             long u = r & REQUESTED_MASK;
-            
+
             // add the current requested amount and the new requested amount
             // cap at Long.MAX_VALUE;
             long v = addCap(u, n);
-            
+
             // restore the completed flag
             v |= c;
-            
+
             if (requested.compareAndSet(r, v)) {
                 // if there was no outstanding request before and in
                 // the post-completed state, start draining
@@ -277,11 +277,11 @@ public static <T, R> boolean postCompleteRequest(AtomicLong requested, long n, Q
             }
         }
     }
-    
+
     /**
      * Drains the queue based on the outstanding requests in post-completed mode (only!)
      * and allows exit transformation on the queued values.
-     * 
+     *
      * @param <T> the value type in the queue
      * @param <R> the value type to emit
      * @param requested the holder of current requested amount
@@ -290,66 +290,66 @@ public static <T, R> boolean postCompleteRequest(AtomicLong requested, long n, Q
      * @param exitTransform the transformation to apply on the dequeued value to get the value to be emitted
      */
     static <T, R> void postCompleteDrain(AtomicLong requested, Queue<T> queue, Subscriber<? super R> subscriber, Func1<? super T, ? extends R> exitTransform) {
-        
+
         long r = requested.get();
-        
+
         // Run on a fast-path if the downstream is unbounded
         if (r == Long.MAX_VALUE) {
             for (;;) {
                 if (subscriber.isUnsubscribed()) {
                     return;
                 }
-                
+
                 T v = queue.poll();
-                
+
                 if (v == null) {
                     subscriber.onCompleted();
                     return;
                 }
-                
+
                 subscriber.onNext(exitTransform.call(v));
             }
         }
         /*
-         * Since we are supposed to be in the post-complete state, 
+         * Since we are supposed to be in the post-complete state,
          * requested will have its top bit set.
          * To allow direct comparison, we start with an emission value which has also
          * this flag set, then increment it as usual.
-         * Since COMPLETED_MASK is essentially Long.MIN_VALUE, 
+         * Since COMPLETED_MASK is essentially Long.MIN_VALUE,
          * there won't be any overflow or sign flip.
          */
         long e = COMPLETED_MASK;
-        
+
         for (;;) {
-            
+
             /*
-             * This is an improved queue-drain algorithm with a specialization 
+             * This is an improved queue-drain algorithm with a specialization
              * in which we know the queue won't change anymore (i.e., done is always true
              * when looking at the classical algorithm and there is no error).
-             * 
+             *
              * Note that we don't check for cancellation or emptiness upfront for two reasons:
              * 1) if e != r, the loop will do this and we quit appropriately
              * 2) if e == r, then either there was no outstanding requests or we emitted the requested amount
              *    and the execution simply falls to the e == r check below which checks for emptiness anyway.
              */
-            
+
             while (e != r) {
                 if (subscriber.isUnsubscribed()) {
                     return;
                 }
-                
+
                 T v = queue.poll();
-                
+
                 if (v == null) {
                     subscriber.onCompleted();
                     return;
                 }
-                
+
                 subscriber.onNext(exitTransform.call(v));
-                
+
                 e++;
             }
-            
+
             /*
              * If the emission count reaches the requested amount the same time the queue becomes empty
              * this will make sure the subscriber is completed immediately instead of on the next request.
@@ -365,15 +365,15 @@ static <T, R> void postCompleteDrain(AtomicLong requested, Queue<T> queue, Subsc
                     return;
                 }
             }
-            
+
             /*
              * Fast flow: see if more requests have arrived in the meantime.
              * This avoids an atomic add (~40 cycles) and resumes the emission immediately.
              */
             r = requested.get();
-            
+
             if (r == e) {
-                /* 
+                /*
                  * Atomically decrement the requested amount by the emission amount.
                  * We can't use the full emission value because of the completed flag,
                  * however, due to two's complement representation, the flag on requested
@@ -413,7 +413,7 @@ public static long produced(AtomicLong requested, long n) {
             }
         }
     }
-    
+
     /**
      * Validates the requested amount and returns true if it is positive.
      * @param n the requested amount
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
index ca8aa231ce..3c2e5cef7a 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java b/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
index 9157bb4877..d7ceea9172 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorNext.java b/src/main/java/rx/internal/operators/BlockingOperatorNext.java
index a7aa16db16..71e789df4f 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorNext.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorNext.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -97,7 +97,7 @@ private boolean moveToNext() {
                     observer.setWaiting(1);
                     ((Observable<T>)items).materialize().subscribe(observer);
                 }
-                
+
                 Notification<? extends T> nextNotification = observer.takeNext();
                 if (nextNotification.isOnNext()) {
                     isNextConsumed = false;
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java b/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
index e4c6acd44f..d6211530cb 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorToFuture.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -34,7 +34,7 @@ private BlockingOperatorToFuture() {
     }
     /**
      * Returns a Future that expects a single item from the observable.
-     * 
+     *
      * @param that
      *            an observable sequence to get a Future for.
      * @param <T>
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java b/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java
index a8d405a3e5..cf12fa834e 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorToIterator.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -28,7 +28,7 @@
  * <p>
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/B.toIterator.png" alt="">
  * <p>
- * 
+ *
  * @see <a href="https://github.com/ReactiveX/RxJava/issues/50">Issue #50</a>
  */
 public final class BlockingOperatorToIterator {
@@ -38,7 +38,7 @@ private BlockingOperatorToIterator() {
 
     /**
      * Returns an iterator that iterates all values of the observable.
-     * 
+     *
      * @param <T>
      *            the type of source.
      * @param source the source Observable
diff --git a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
index e517cbc9db..fc0001153c 100644
--- a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
+++ b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -77,7 +77,7 @@ boolean casObserverRef(Observer<? super T>  expected, Observer<? super T>  next)
             return compareAndSet(expected, next);
         }
     }
-    
+
     static final class OnSubscribeAction<T> implements OnSubscribe<T> {
         final State<T> state;
 
@@ -124,7 +124,7 @@ public void call() {
                 s.onError(new IllegalStateException("Only one subscriber allowed!"));
             }
         }
-        
+
     }
 
     private BufferUntilSubscriber(State<T> state) {
@@ -206,7 +206,7 @@ public void onError(Throwable e) {
         public void onNext(Object t) {
             // deliberately no op
         }
-        
+
     };
-    
+
 }
diff --git a/src/main/java/rx/internal/operators/CachedObservable.java b/src/main/java/rx/internal/operators/CachedObservable.java
index c9b6c47cda..4f5cff5b04 100644
--- a/src/main/java/rx/internal/operators/CachedObservable.java
+++ b/src/main/java/rx/internal/operators/CachedObservable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -43,7 +43,7 @@ public final class CachedObservable<T> extends Observable<T> {
     public static <T> CachedObservable<T> from(Observable<? extends T> source) {
         return (CachedObservable<T>)from(source, 16);
     }
-    
+
     /**
      * Creates a cached Observable with the given capacity hint.
      * @param <T> the value type
@@ -59,7 +59,7 @@ public static <T> CachedObservable<T> from(Observable<? extends T> source, int c
         CachedSubscribe<T> onSubscribe = new CachedSubscribe<T>(state);
         return new CachedObservable<T>(onSubscribe, state);
     }
-    
+
     /**
      * Private constructor because state needs to be shared between the Observable body and
      * the onSubscribe function.
@@ -78,7 +78,7 @@ private CachedObservable(OnSubscribe<T> onSubscribe, CacheState<T> state) {
     /* public */boolean isConnected() {
         return state.isConnected;
     }
-    
+
     /**
      * Returns true if there are observers subscribed to this observable.
      * @return
@@ -101,17 +101,17 @@ static final class CacheState<T> extends LinkedArrayList implements Observer<T>
         volatile ReplayProducer<?>[] producers;
         /** The default empty array of producers. */
         static final ReplayProducer<?>[] EMPTY = new ReplayProducer<?>[0];
-        
+
         final NotificationLite<T> nl;
-        
+
         /** Set to true after connection. */
         volatile boolean isConnected;
-        /** 
+        /**
          * Indicates that the source has completed emitting values or the
          * Observable was forcefully terminated.
          */
         boolean sourceDone;
-        
+
         public CacheState(Observable<? extends T> source, int capacityHint) {
             super(capacityHint);
             this.source = source;
@@ -224,7 +224,7 @@ void dispatch() {
             }
         }
     }
-    
+
     /**
      * Manages the subscription of child subscribers by setting up a replay producer and
      * performs auto-connection of the very first subscription.
@@ -242,7 +242,7 @@ public void call(Subscriber<? super T> t) {
             // we can connect first because we replay everything anyway
             ReplayProducer<T> rp = new ReplayProducer<T>(t, state);
             state.addProducer(rp);
-            
+
             t.add(rp);
             t.setProducer(rp);
 
@@ -250,11 +250,11 @@ public void call(Subscriber<? super T> t) {
             if (!get() && compareAndSet(false, true)) {
                 state.connect();
             }
-            
+
             // no need to call rp.replay() here because the very first request will trigger it anyway
         }
     }
-    
+
     /**
      * Keeps track of the current request amount and the replay position for a child Subscriber.
      *
@@ -267,14 +267,14 @@ static final class ReplayProducer<T> extends AtomicLong implements Producer, Sub
         final Subscriber<? super T> child;
         /** The cache state object. */
         final CacheState<T> state;
-        
-        /** 
+
+        /**
          * Contains the reference to the buffer segment in replay.
          * Accessed after reading state.size() and when emitting == true.
          */
         Object[] currentBuffer;
-        /** 
-         * Contains the index into the currentBuffer where the next value is expected. 
+        /**
+         * Contains the index into the currentBuffer where the next value is expected.
          * Accessed after reading state.size() and when emitting == true.
          */
         int currentIndexInBuffer;
@@ -287,7 +287,7 @@ static final class ReplayProducer<T> extends AtomicLong implements Producer, Sub
         boolean emitting;
         /** Indicates there were some state changes/replay attempts; guarded by this. */
         boolean missed;
-        
+
         public ReplayProducer(Subscriber<? super T> child, CacheState<T> state) {
             this.child = child;
             this.state = state;
@@ -317,7 +317,7 @@ public void request(long n) {
         public long produced(long n) {
             return addAndGet(-n);
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return get() < 0;
@@ -332,7 +332,7 @@ public void unsubscribe() {
                 }
             }
         }
-        
+
         /**
          * Continue replaying available values if there are requests for them.
          */
@@ -349,22 +349,22 @@ public void replay() {
             try {
                 final NotificationLite<T> nl = state.nl;
                 final Subscriber<? super T> child = this.child;
-                
+
                 for (;;) {
-                    
+
                     long r = get();
-                    
+
                     if (r < 0L) {
                         skipFinal = true;
                         return;
                     }
-                        
+
                     // read the size, if it is non-zero, we can safely read the head and
                     // read values up to the given absolute index
                     int s = state.size();
                     if (s != 0) {
                         Object[] b = currentBuffer;
-                        
+
                         // latch onto the very first buffer now that it is available.
                         if (b == null) {
                             b = state.head();
@@ -391,7 +391,7 @@ public void replay() {
                         } else
                         if (r > 0) {
                             int valuesProduced = 0;
-                            
+
                             while (j < s && r > 0) {
                                 if (child.isUnsubscribed()) {
                                     skipFinal = true;
@@ -402,7 +402,7 @@ public void replay() {
                                     k = 0;
                                 }
                                 Object o = b[k];
-                                
+
                                 try {
                                     if (nl.accept(child, o)) {
                                         skipFinal = true;
@@ -418,25 +418,25 @@ public void replay() {
                                     }
                                     return;
                                 }
-                                
+
                                 k++;
                                 j++;
                                 r--;
                                 valuesProduced++;
                             }
-                            
+
                             if (child.isUnsubscribed()) {
                                 skipFinal = true;
                                 return;
                             }
-                            
+
                             index = j;
                             currentIndexInBuffer = k;
                             currentBuffer = b;
                             produced(valuesProduced);
                         }
                     }
-                    
+
                     synchronized (this) {
                         if (!missed) {
                             emitting = false;
diff --git a/src/main/java/rx/internal/operators/CompletableFromEmitter.java b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
index ac94a1ae94..912c147a5c 100644
--- a/src/main/java/rx/internal/operators/CompletableFromEmitter.java
+++ b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
@@ -35,22 +35,22 @@ public final class CompletableFromEmitter implements Completable.OnSubscribe {
     public CompletableFromEmitter(Action1<CompletableEmitter> producer) {
         this.producer = producer;
     }
-    
+
     @Override
     public void call(CompletableSubscriber t) {
         FromEmitter emitter = new FromEmitter(t);
         t.onSubscribe(emitter);
-        
+
         try {
             producer.call(emitter);
         } catch (Throwable ex) {
             Exceptions.throwIfFatal(ex);
             emitter.onError(ex);
         }
-        
+
     }
-    
-    static final class FromEmitter 
+
+    static final class FromEmitter
     extends AtomicBoolean
     implements CompletableEmitter, Subscription {
 
@@ -58,14 +58,14 @@ static final class FromEmitter
         private static final long serialVersionUID = 5539301318568668881L;
 
         final CompletableSubscriber actual;
-        
+
         final SequentialSubscription resource;
-        
+
         public FromEmitter(CompletableSubscriber actual) {
             this.actual = actual;
             resource = new SequentialSubscription();
         }
-        
+
         @Override
         public void onCompleted() {
             if (compareAndSet(false, true)) {
@@ -111,6 +111,6 @@ public void unsubscribe() {
         public boolean isUnsubscribed() {
             return get();
         }
-        
+
     }
 }
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
index a7580d417e..1960a93207 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -28,35 +28,35 @@
 public final class CompletableOnSubscribeConcat implements OnSubscribe {
     final Observable<Completable> sources;
     final int prefetch;
-    
+
     @SuppressWarnings("unchecked")
     public CompletableOnSubscribeConcat(Observable<? extends Completable> sources, int prefetch) {
         this.sources = (Observable<Completable>)sources;
         this.prefetch = prefetch;
     }
-    
+
     @Override
     public void call(CompletableSubscriber s) {
         CompletableConcatSubscriber parent = new CompletableConcatSubscriber(s, prefetch);
         s.onSubscribe(parent);
         sources.subscribe(parent);
     }
-    
+
     static final class CompletableConcatSubscriber
     extends Subscriber<Completable> {
         final CompletableSubscriber actual;
         final SerialSubscription sr;
-        
+
         final SpscArrayQueue<Completable> queue;
-        
+
         volatile boolean done;
 
         final AtomicBoolean once;
-        
+
         final ConcatInnerSubscriber inner;
-        
+
         final AtomicInteger wip;
-        
+
         public CompletableConcatSubscriber(CompletableSubscriber actual, int prefetch) {
             this.actual = actual;
             this.queue = new SpscArrayQueue<Completable>(prefetch);
@@ -67,7 +67,7 @@ public CompletableConcatSubscriber(CompletableSubscriber actual, int prefetch) {
             add(sr);
             request(prefetch);
         }
-        
+
         @Override
         public void onNext(Completable t) {
             if (!queue.offer(t)) {
@@ -78,7 +78,7 @@ public void onNext(Completable t) {
                 next();
             }
         }
-        
+
         @Override
         public void onError(Throwable t) {
             if (once.compareAndSet(false, true)) {
@@ -87,7 +87,7 @@ public void onError(Throwable t) {
             }
             RxJavaHooks.onError(t);
         }
-        
+
         @Override
         public void onCompleted() {
             if (done) {
@@ -98,12 +98,12 @@ public void onCompleted() {
                 next();
             }
         }
-        
+
         void innerError(Throwable e) {
             unsubscribe();
             onError(e);
         }
-        
+
         void innerComplete() {
             if (wip.decrementAndGet() != 0) {
                 next();
@@ -112,7 +112,7 @@ void innerComplete() {
                 request(1);
             }
         }
-        
+
         void next() {
             boolean d = done;
             Completable c = queue.poll();
@@ -126,21 +126,21 @@ void next() {
                 RxJavaHooks.onError(new IllegalStateException("Queue is empty?!"));
                 return;
             }
-            
+
             c.unsafeSubscribe(inner);
         }
-        
+
         final class ConcatInnerSubscriber implements CompletableSubscriber {
             @Override
             public void onSubscribe(Subscription d) {
                 sr.set(d);
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 innerError(e);
             }
-            
+
             @Override
             public void onCompleted() {
                 innerComplete();
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
index 00b033e442..f291f0f649 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -24,55 +24,55 @@
 
 public final class CompletableOnSubscribeConcatArray implements OnSubscribe {
     final Completable[] sources;
-    
+
     public CompletableOnSubscribeConcatArray(Completable[] sources) {
         this.sources = sources;
     }
-    
+
     @Override
     public void call(CompletableSubscriber s) {
         ConcatInnerSubscriber inner = new ConcatInnerSubscriber(s, sources);
         s.onSubscribe(inner.sd);
         inner.next();
     }
-    
+
     static final class ConcatInnerSubscriber extends AtomicInteger implements CompletableSubscriber {
         /** */
         private static final long serialVersionUID = -7965400327305809232L;
 
         final CompletableSubscriber actual;
         final Completable[] sources;
-        
+
         int index;
-        
+
         final SerialSubscription sd;
-        
+
         public ConcatInnerSubscriber(CompletableSubscriber actual, Completable[] sources) {
             this.actual = actual;
             this.sources = sources;
             this.sd = new SerialSubscription();
         }
-        
+
         @Override
         public void onSubscribe(Subscription d) {
             sd.set(d);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             actual.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             next();
         }
-        
+
         void next() {
             if (sd.isUnsubscribed()) {
                 return;
             }
-            
+
             if (getAndIncrement() != 0) {
                 return;
             }
@@ -82,13 +82,13 @@ void next() {
                 if (sd.isUnsubscribed()) {
                     return;
                 }
-                
+
                 int idx = index++;
                 if (idx == a.length) {
                     actual.onCompleted();
                     return;
                 }
-                
+
                 a[idx].unsafeSubscribe(this);
             } while (decrementAndGet() != 0);
         }
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
index 9d42d6187f..e5a3e95fc7 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -25,16 +25,16 @@
 
 public final class CompletableOnSubscribeConcatIterable implements OnSubscribe {
     final Iterable<? extends Completable> sources;
-    
+
     public CompletableOnSubscribeConcatIterable(Iterable<? extends Completable> sources) {
         this.sources = sources;
     }
-    
+
     @Override
     public void call(CompletableSubscriber s) {
-        
+
         Iterator<? extends Completable> it;
-        
+
         try {
             it = sources.iterator();
         } catch (Throwable e) {
@@ -42,53 +42,53 @@ public void call(CompletableSubscriber s) {
             s.onError(e);
             return;
         }
-        
+
         if (it == null) {
             s.onSubscribe(Subscriptions.unsubscribed());
             s.onError(new NullPointerException("The iterator returned is null"));
             return;
         }
-        
+
         ConcatInnerSubscriber inner = new ConcatInnerSubscriber(s, it);
         s.onSubscribe(inner.sd);
         inner.next();
     }
-    
+
     static final class ConcatInnerSubscriber extends AtomicInteger implements CompletableSubscriber {
         /** */
         private static final long serialVersionUID = -7965400327305809232L;
 
         final CompletableSubscriber actual;
         final Iterator<? extends Completable> sources;
-        
+
         final SerialSubscription sd;
-        
+
         public ConcatInnerSubscriber(CompletableSubscriber actual, Iterator<? extends Completable> sources) {
             this.actual = actual;
             this.sources = sources;
             this.sd = new SerialSubscription();
         }
-        
+
         @Override
         public void onSubscribe(Subscription d) {
             sd.set(d);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             actual.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             next();
         }
-        
+
         void next() {
             if (sd.isUnsubscribed()) {
                 return;
             }
-            
+
             if (getAndIncrement() != 0) {
                 return;
             }
@@ -98,7 +98,7 @@ void next() {
                 if (sd.isUnsubscribed()) {
                     return;
                 }
-                
+
                 boolean b;
                 try {
                     b = a.hasNext();
@@ -106,26 +106,26 @@ void next() {
                     actual.onError(ex);
                     return;
                 }
-                
+
                 if (!b) {
                     actual.onCompleted();
                     return;
                 }
-                
+
                 Completable c;
-                
+
                 try {
                     c = a.next();
                 } catch (Throwable ex) {
                     actual.onError(ex);
                     return;
                 }
-                
+
                 if (c == null) {
                     actual.onError(new NullPointerException("The completable returned is null"));
                     return;
                 }
-                
+
                 c.unsafeSubscribe(this);
             } while (decrementAndGet() != 0);
         }
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
index 38554fa302..19f5aa3857 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -31,35 +31,35 @@ public final class CompletableOnSubscribeMerge implements OnSubscribe {
     final Observable<Completable> source;
     final int maxConcurrency;
     final boolean delayErrors;
-    
+
     @SuppressWarnings("unchecked")
     public CompletableOnSubscribeMerge(Observable<? extends Completable> source, int maxConcurrency, boolean delayErrors) {
         this.source = (Observable<Completable>)source;
         this.maxConcurrency = maxConcurrency;
         this.delayErrors = delayErrors;
     }
-    
+
     @Override
     public void call(CompletableSubscriber s) {
         CompletableMergeSubscriber parent = new CompletableMergeSubscriber(s, maxConcurrency, delayErrors);
         s.onSubscribe(parent);
         source.subscribe(parent);
     }
-    
+
     static final class CompletableMergeSubscriber
     extends Subscriber<Completable> {
         final CompletableSubscriber actual;
         final CompositeSubscription set;
         final boolean delayErrors;
-        
+
         volatile boolean done;
-        
+
         final AtomicReference<Queue<Throwable>> errors;
-        
+
         final AtomicBoolean once;
-        
+
         final AtomicInteger wip;
-        
+
         public CompletableMergeSubscriber(CompletableSubscriber actual, int maxConcurrency, boolean delayErrors) {
             this.actual = actual;
             this.delayErrors = delayErrors;
@@ -73,14 +73,14 @@ public CompletableMergeSubscriber(CompletableSubscriber actual, int maxConcurren
                 request(maxConcurrency);
             }
         }
-        
+
         Queue<Throwable> getOrCreateErrors() {
             Queue<Throwable> q = errors.get();
-            
+
             if (q != null) {
                 return q;
             }
-            
+
             q = new ConcurrentLinkedQueue<Throwable>();
             if (errors.compareAndSet(null, q)) {
                 return q;
@@ -95,7 +95,7 @@ public void onNext(Completable t) {
             }
 
             wip.getAndIncrement();
-            
+
             t.unsafeSubscribe(new CompletableSubscriber() {
                 Subscription d;
                 boolean innerDone;
@@ -104,7 +104,7 @@ public void onSubscribe(Subscription d) {
                     this.d = d;
                     set.add(d);
                 }
-                
+
                 @Override
                 public void onError(Throwable e) {
                     if (innerDone) {
@@ -113,16 +113,16 @@ public void onError(Throwable e) {
                     }
                     innerDone = true;
                     set.remove(d);
-                    
+
                     getOrCreateErrors().offer(e);
-                    
+
                     terminate();
-                    
+
                     if (delayErrors && !done) {
                         request(1);
                     }
                 }
-                
+
                 @Override
                 public void onCompleted() {
                     if (innerDone) {
@@ -130,9 +130,9 @@ public void onCompleted() {
                     }
                     innerDone = true;
                     set.remove(d);
-                    
+
                     terminate();
-                    
+
                     if (!done) {
                         request(1);
                     }
@@ -187,7 +187,7 @@ void terminate() {
             }
         }
     }
-    
+
     /**
      * Collects the Throwables from the queue, adding subsequent Throwables as suppressed to
      * the first Throwable and returns it.
@@ -196,7 +196,7 @@ void terminate() {
      */
     public static Throwable collectErrors(Queue<Throwable> q) {
         List<Throwable> list = new ArrayList<Throwable>();
-        
+
         Throwable t;
         while ((t = q.poll()) != null) {
             list.add(t);
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
index 7af6636d28..7f5dbeed0e 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeArray.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -25,24 +25,24 @@
 
 public final class CompletableOnSubscribeMergeArray implements OnSubscribe {
     final Completable[] sources;
-    
+
     public CompletableOnSubscribeMergeArray(Completable[] sources) {
         this.sources = sources;
     }
-    
+
     @Override
     public void call(final CompletableSubscriber s) {
         final CompositeSubscription set = new CompositeSubscription();
         final AtomicInteger wip = new AtomicInteger(sources.length + 1);
         final AtomicBoolean once = new AtomicBoolean();
-        
+
         s.onSubscribe(set);
-        
+
         for (Completable c : sources) {
             if (set.isUnsubscribed()) {
                 return;
             }
-            
+
             if (c == null) {
                 set.unsubscribe();
                 NullPointerException npe = new NullPointerException("A completable source is null");
@@ -53,7 +53,7 @@ public void call(final CompletableSubscriber s) {
                     RxJavaHooks.onError(npe);
                 }
             }
-            
+
             c.unsafeSubscribe(new CompletableSubscriber() {
                 @Override
                 public void onSubscribe(Subscription d) {
@@ -78,10 +78,10 @@ public void onCompleted() {
                         }
                     }
                 }
-                
+
             });
         }
-        
+
         if (wip.decrementAndGet() == 0) {
             if (once.compareAndSet(false, true)) {
                 s.onCompleted();
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java
index d8dfac8f2f..db93cf7cc7 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorArray.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -26,31 +26,31 @@
 
 public final class CompletableOnSubscribeMergeDelayErrorArray implements OnSubscribe {
     final Completable[] sources;
-    
+
     public CompletableOnSubscribeMergeDelayErrorArray(Completable[] sources) {
         this.sources = sources;
     }
-    
+
     @Override
     public void call(final CompletableSubscriber s) {
         final CompositeSubscription set = new CompositeSubscription();
         final AtomicInteger wip = new AtomicInteger(sources.length + 1);
-        
+
         final Queue<Throwable> q = new ConcurrentLinkedQueue<Throwable>();
-        
+
         s.onSubscribe(set);
-        
+
         for (Completable c : sources) {
             if (set.isUnsubscribed()) {
                 return;
             }
-            
+
             if (c == null) {
                 q.offer(new NullPointerException("A completable source is null"));
                 wip.decrementAndGet();
                 continue;
             }
-            
+
             c.unsafeSubscribe(new CompletableSubscriber() {
                 @Override
                 public void onSubscribe(Subscription d) {
@@ -67,7 +67,7 @@ public void onError(Throwable e) {
                 public void onCompleted() {
                     tryTerminate();
                 }
-                
+
                 void tryTerminate() {
                     if (wip.decrementAndGet() == 0) {
                         if (q.isEmpty()) {
@@ -77,10 +77,10 @@ void tryTerminate() {
                         }
                     }
                 }
-                
+
             });
         }
-        
+
         if (wip.decrementAndGet() == 0) {
             if (q.isEmpty()) {
                 s.onCompleted();
@@ -88,6 +88,6 @@ void tryTerminate() {
                 s.onError(CompletableOnSubscribeMerge.collectErrors(q));
             }
         }
-        
+
     }
 }
\ No newline at end of file
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
index 6678439526..20477e64fd 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -26,40 +26,40 @@
 
 public final class CompletableOnSubscribeMergeDelayErrorIterable implements OnSubscribe {
     final Iterable<? extends Completable> sources;
-    
+
     public CompletableOnSubscribeMergeDelayErrorIterable(Iterable<? extends Completable> sources) {
         this.sources = sources;
     }
-    
+
     @Override
     public void call(final CompletableSubscriber s) {
         final CompositeSubscription set = new CompositeSubscription();
-        
+
         s.onSubscribe(set);
-        
+
         Iterator<? extends Completable> iterator;
-        
+
         try {
             iterator = sources.iterator();
         } catch (Throwable e) {
             s.onError(e);
             return;
         }
-        
+
         if (iterator == null) {
             s.onError(new NullPointerException("The source iterator returned is null"));
             return;
         }
 
         final AtomicInteger wip = new AtomicInteger(1);
-        
+
         final Queue<Throwable> queue = new MpscLinkedQueue<Throwable>();
 
         for (;;) {
             if (set.isUnsubscribed()) {
                 return;
             }
-            
+
             boolean b;
             try {
                 b = iterator.hasNext();
@@ -74,17 +74,17 @@ public void call(final CompletableSubscriber s) {
                 }
                 return;
             }
-                    
+
             if (!b) {
                 break;
             }
-            
+
             if (set.isUnsubscribed()) {
                 return;
             }
-            
+
             Completable c;
-            
+
             try {
                 c = iterator.next();
             } catch (Throwable e) {
@@ -98,11 +98,11 @@ public void call(final CompletableSubscriber s) {
                 }
                 return;
             }
-            
+
             if (set.isUnsubscribed()) {
                 return;
             }
-            
+
             if (c == null) {
                 NullPointerException e = new NullPointerException("A completable source is null");
                 queue.offer(e);
@@ -115,9 +115,9 @@ public void call(final CompletableSubscriber s) {
                 }
                 return;
             }
-            
+
             wip.getAndIncrement();
-            
+
             c.unsafeSubscribe(new CompletableSubscriber() {
                 @Override
                 public void onSubscribe(Subscription d) {
@@ -134,7 +134,7 @@ public void onError(Throwable e) {
                 public void onCompleted() {
                     tryTerminate();
                 }
-                
+
                 void tryTerminate() {
                     if (wip.decrementAndGet() == 0) {
                         if (queue.isEmpty()) {
@@ -146,7 +146,7 @@ void tryTerminate() {
                 }
             });
         }
-        
+
         if (wip.decrementAndGet() == 0) {
             if (queue.isEmpty()) {
                 s.onCompleted();
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
index 459996d0c4..fb737c77e7 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeIterable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -26,31 +26,31 @@
 
 public final class CompletableOnSubscribeMergeIterable implements OnSubscribe {
     final Iterable<? extends Completable> sources;
-    
+
     public CompletableOnSubscribeMergeIterable(Iterable<? extends Completable> sources) {
         this.sources = sources;
     }
-    
+
     @Override
     public void call(final CompletableSubscriber s) {
         final CompositeSubscription set = new CompositeSubscription();
 
         s.onSubscribe(set);
-        
+
         Iterator<? extends Completable> iterator;
-        
+
         try {
             iterator = sources.iterator();
         } catch (Throwable e) {
             s.onError(e);
             return;
         }
-        
+
         if (iterator == null) {
             s.onError(new NullPointerException("The source iterator returned is null"));
             return;
         }
-        
+
         final AtomicInteger wip = new AtomicInteger(1);
         final AtomicBoolean once = new AtomicBoolean();
 
@@ -58,7 +58,7 @@ public void call(final CompletableSubscriber s) {
             if (set.isUnsubscribed()) {
                 return;
             }
-            
+
             boolean b;
             try {
                 b = iterator.hasNext();
@@ -71,17 +71,17 @@ public void call(final CompletableSubscriber s) {
                 }
                 return;
             }
-                    
+
             if (!b) {
                 break;
             }
-            
+
             if (set.isUnsubscribed()) {
                 return;
             }
-            
+
             Completable c;
-            
+
             try {
                 c = iterator.next();
             } catch (Throwable e) {
@@ -93,11 +93,11 @@ public void call(final CompletableSubscriber s) {
                 }
                 return;
             }
-            
+
             if (set.isUnsubscribed()) {
                 return;
             }
-            
+
             if (c == null) {
                 set.unsubscribe();
                 NullPointerException npe = new NullPointerException("A completable source is null");
@@ -108,9 +108,9 @@ public void call(final CompletableSubscriber s) {
                 }
                 return;
             }
-            
+
             wip.getAndIncrement();
-            
+
             c.unsafeSubscribe(new CompletableSubscriber() {
                 @Override
                 public void onSubscribe(Subscription d) {
@@ -135,10 +135,10 @@ public void onCompleted() {
                         }
                     }
                 }
-                
+
             });
         }
-        
+
         if (wip.decrementAndGet() == 0) {
             if (once.compareAndSet(false, true)) {
                 s.onCompleted();
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
index e88d6ae427..5ca8ce2d58 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeTimeout.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -26,14 +26,14 @@
 import rx.subscriptions.CompositeSubscription;
 
 public final class CompletableOnSubscribeTimeout implements OnSubscribe {
-    
+
     final Completable source;
     final long timeout;
     final TimeUnit unit;
     final Scheduler scheduler;
     final Completable other;
 
-    public CompletableOnSubscribeTimeout(Completable source, long timeout, 
+    public CompletableOnSubscribeTimeout(Completable source, long timeout,
             TimeUnit unit, Scheduler scheduler, Completable other) {
         this.source = source;
         this.timeout = timeout;
@@ -46,11 +46,11 @@ public CompletableOnSubscribeTimeout(Completable source, long timeout,
     public void call(final CompletableSubscriber s) {
         final CompositeSubscription set = new CompositeSubscription();
         s.onSubscribe(set);
-        
+
         final AtomicBoolean once = new AtomicBoolean();
-        
+
         Scheduler.Worker w = scheduler.createWorker();
-        
+
         set.add(w);
         w.schedule(new Action0() {
             @Override
@@ -61,30 +61,30 @@ public void call() {
                         s.onError(new TimeoutException());
                     } else {
                         other.unsafeSubscribe(new CompletableSubscriber() {
-   
+
                             @Override
                             public void onSubscribe(Subscription d) {
                                 set.add(d);
                             }
-   
+
                             @Override
                             public void onError(Throwable e) {
                                 set.unsubscribe();
                                 s.onError(e);
                             }
-   
+
                             @Override
                             public void onCompleted() {
                                 set.unsubscribe();
                                 s.onCompleted();
                             }
-                            
+
                         });
                     }
                 }
             }
         }, timeout, unit);
-        
+
         source.unsafeSubscribe(new CompletableSubscriber() {
 
             @Override
@@ -109,7 +109,7 @@ public void onCompleted() {
                     s.onCompleted();
                 }
             }
-            
+
         });
     }
 }
\ No newline at end of file
diff --git a/src/main/java/rx/internal/operators/DeferredScalarSubscriber.java b/src/main/java/rx/internal/operators/DeferredScalarSubscriber.java
index 2cdfccaed2..bff33bfc72 100644
--- a/src/main/java/rx/internal/operators/DeferredScalarSubscriber.java
+++ b/src/main/java/rx/internal/operators/DeferredScalarSubscriber.java
@@ -29,7 +29,7 @@
  * <p.
  * Use {@link #subscribeTo(Observable)} to properly setup the link between this and the downstream
  * subscriber.
- * 
+ *
  * @param <T> the source value type
  * @param <R> the result value type
  */
@@ -37,16 +37,16 @@ public abstract class DeferredScalarSubscriber<T, R> extends Subscriber<T> {
 
     /** The downstream subscriber. */
     protected final Subscriber<? super R> actual;
-    
+
     /** Indicates there is a value available in value. */
     protected boolean hasValue;
-    
+
     /** The holder of the single value. */
     protected R value;
-    
+
     /** The state, see the constants below. */
     final AtomicInteger state;
-    
+
     /** Initial state. */
     static final int NO_REQUEST_NO_VALUE = 0;
     /** Request came first. */
@@ -55,18 +55,18 @@ public abstract class DeferredScalarSubscriber<T, R> extends Subscriber<T> {
     static final int NO_REQUEST_HAS_VALUE = 2;
     /** Value will be emitted. */
     static final int HAS_REQUEST_HAS_VALUE = 3;
-    
+
     public DeferredScalarSubscriber(Subscriber<? super R> actual) {
         this.actual = actual;
         this.state = new AtomicInteger();
     }
-    
+
     @Override
     public void onError(Throwable ex) {
         value = null;
         actual.onError(ex);
     }
-    
+
     @Override
     public void onCompleted() {
         if (hasValue) {
@@ -75,14 +75,14 @@ public void onCompleted() {
             complete();
         }
     }
-    
+
     /**
      * Signals onCompleted() to the downstream subscriber.
      */
     protected final void complete() {
         actual.onCompleted();
     }
-    
+
     /**
      * Atomically switches to the terminal state and emits the value if
      * there is a request for it or stores it for retrieval by {@code downstreamRequest(long)}.
@@ -92,7 +92,7 @@ protected final void complete(R value) {
         Subscriber<? super R> a = actual;
         for (;;) {
             int s = state.get();
-            
+
             if (s == NO_REQUEST_HAS_VALUE || s == HAS_REQUEST_HAS_VALUE || a.isUnsubscribed()) {
                 return;
             }
@@ -110,7 +110,7 @@ protected final void complete(R value) {
             }
         }
     }
-    
+
     final void downstreamRequest(long n) {
         if (n < 0L) {
             throw new IllegalArgumentException("n >= 0 required but it was " + n);
@@ -137,12 +137,12 @@ final void downstreamRequest(long n) {
             }
         }
     }
-    
+
     @Override
     public final void setProducer(Producer p) {
         p.request(Long.MAX_VALUE);
     }
-    
+
     /**
      * Links up with the downstream Subscriber (cancellation, backpressure) and
      * subscribes to the source Observable.
@@ -152,13 +152,13 @@ public final void subscribeTo(Observable<? extends T> source) {
         setupDownstream();
         source.unsafeSubscribe(this);
     }
-    
+
     /* test */ final void setupDownstream() {
         Subscriber<? super R> a = actual;
         a.add(this);
         a.setProducer(new InnerProducer(this));
     }
-    
+
     /**
      * Redirects the downstream request amount bach to the DeferredScalarSubscriber.
      */
@@ -168,7 +168,7 @@ static final class InnerProducer implements Producer {
         public InnerProducer(DeferredScalarSubscriber<?, ?> parent) {
             this.parent = parent;
         }
-        
+
         @Override
         public void request(long n) {
             parent.downstreamRequest(n);
diff --git a/src/main/java/rx/internal/operators/DeferredScalarSubscriberSafe.java b/src/main/java/rx/internal/operators/DeferredScalarSubscriberSafe.java
index 3ec25c404a..2455819dd3 100644
--- a/src/main/java/rx/internal/operators/DeferredScalarSubscriberSafe.java
+++ b/src/main/java/rx/internal/operators/DeferredScalarSubscriberSafe.java
@@ -23,14 +23,14 @@
  * Supplements {@code DeferredScalarSubscriber} with defensive behaviour that ensures no emissions
  * occur after a terminal event. If {@code onError} is called more than once then errors after the first
  * are reported to {@code RxJavaHooks.onError}.
- * 
+ *
  * @param <T> source value type
  * @param <R> result value type
  */
 public abstract class DeferredScalarSubscriberSafe<T, R> extends DeferredScalarSubscriber<T,R> {
 
     protected boolean done;
-    
+
     public DeferredScalarSubscriberSafe(Subscriber<? super R> actual) {
         super(actual);
     }
@@ -53,5 +53,5 @@ public void onCompleted() {
         done = true;
         super.onCompleted();
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/operators/EmptyObservableHolder.java b/src/main/java/rx/internal/operators/EmptyObservableHolder.java
index c9678db92d..e582407bee 100644
--- a/src/main/java/rx/internal/operators/EmptyObservableHolder.java
+++ b/src/main/java/rx/internal/operators/EmptyObservableHolder.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -29,7 +29,7 @@ public enum EmptyObservableHolder implements OnSubscribe<Object> {
 
     /** The singleton instance. */
     static final Observable<Object> EMPTY = Observable.create(INSTANCE);
-    
+
 
     /**
      * Returns a type-corrected singleton instance of the empty Observable.
@@ -40,7 +40,7 @@ public enum EmptyObservableHolder implements OnSubscribe<Object> {
     public static <T> Observable<T> instance() {
         return (Observable<T>)EMPTY;
     }
-    
+
     @Override
     public void call(Subscriber<? super Object> child) {
         child.onCompleted();
diff --git a/src/main/java/rx/internal/operators/NeverObservableHolder.java b/src/main/java/rx/internal/operators/NeverObservableHolder.java
index 4ffdc630d8..6a80d22e8b 100644
--- a/src/main/java/rx/internal/operators/NeverObservableHolder.java
+++ b/src/main/java/rx/internal/operators/NeverObservableHolder.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -39,7 +39,7 @@ public enum NeverObservableHolder implements OnSubscribe<Object> {
     public static <T> Observable<T> instance() {
         return (Observable<T>)NEVER;
     }
-    
+
     @Override
     public void call(Subscriber<? super Object> child) {
         // deliberately no op
diff --git a/src/main/java/rx/internal/operators/NotificationLite.java b/src/main/java/rx/internal/operators/NotificationLite.java
index 7047553dc9..205d0f556c 100644
--- a/src/main/java/rx/internal/operators/NotificationLite.java
+++ b/src/main/java/rx/internal/operators/NotificationLite.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -30,7 +30,7 @@
  * affect performance because exceptions should be exceptionally rare.
  * <p>
  * It's implemented as a singleton to maintain some semblance of type safety that is completely non-existent.
- * 
+ *
  * @param <T> the element type
  */
 public final class NotificationLite<T> {
@@ -54,7 +54,7 @@ public static <T> NotificationLite<T> instance() {
 
     private static final Object ON_COMPLETED_SENTINEL = new Serializable() {
         private static final long serialVersionUID = 1;
-        
+
         @Override
         public String toString() {
             return "Notification=>Completed";
@@ -63,7 +63,7 @@ public String toString() {
 
     private static final Object ON_NEXT_NULL_SENTINEL = new Serializable() {
         private static final long serialVersionUID = 2;
-        
+
         @Override
         public String toString() {
             return "Notification=>NULL";
@@ -77,7 +77,7 @@ static final class OnErrorSentinel implements Serializable {
         public OnErrorSentinel(Throwable e) {
             this.e = e;
         }
-        
+
         @Override
         public String toString() {
             return "Notification=>Error:" + e;
@@ -87,7 +87,7 @@ public String toString() {
     /**
      * Creates a lite {@code onNext} notification for the value passed in without doing any allocation. Can
      * be unwrapped and sent with the {@link #accept} method.
-     * 
+     *
      * @param t
      *          the item emitted to {@code onNext}
      * @return the item, or a null token representing the item if the item is {@code null}
@@ -103,7 +103,7 @@ public Object next(T t) {
     /**
      * Creates a lite {@code onCompleted} notification without doing any allocation. Can be unwrapped and
      * sent with the {@link #accept} method.
-     * 
+     *
      * @return a completion token
      */
     public Object completed() {
@@ -114,7 +114,7 @@ public Object completed() {
      * Create a lite {@code onError} notification. This call creates an object to wrap the {@link Throwable},
      * but since there should only be one of these, the performance impact should be small. Can be unwrapped and
      * sent with the {@link #accept} method.
-     * 
+     *
      * @param e
      *           the {@code Throwable} in the {@code onError} notification
      * @return an object encapsulating the exception
@@ -125,7 +125,7 @@ public Object error(Throwable e) {
 
     /**
      * Unwraps the lite notification and calls the appropriate method on the {@link Observer}.
-     * 
+     *
      * @param o
      *            the {@link Observer} to call {@code onNext}, {@code onCompleted}, or {@code onError}.
      * @param n
@@ -199,7 +199,7 @@ public boolean isNext(Object n) {
      * Indicates which variety a particular lite notification is. If you need something more complex than
      * simply calling the right method on an {@link Observer} then you can use this method to get the
      * {@link rx.Notification.Kind}.
-     * 
+     *
      * @param n
      *            the lite notification
      * @throws IllegalArgumentException
@@ -224,7 +224,7 @@ public Kind kind(Object n) {
      * Returns the item corresponding to this {@code OnNext} lite notification. Bad things happen if you pass
      * this an {@code OnComplete} or {@code OnError} notification type. For performance reasons, this method
      * does not check for this, so you are expected to prevent such a mishap.
-     * 
+     *
      * @param n
      *            the lite notification (of type {@code Kind.OnNext})
      * @return the unwrapped value, which can be null
@@ -238,7 +238,7 @@ public T getValue(Object n) {
      * Returns the {@link Throwable} corresponding to this {@code OnError} lite notification. Bad things happen
      * if you pass this an {@code OnComplete} or {@code OnNext} notification type. For performance reasons, this
      * method does not check for this, so you are expected to prevent such a mishap.
-     * 
+     *
      * @param n
      *            the lite notification (of type {@code Kind.OnError})
      * @return the {@link Throwable} wrapped inside {@code n}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeAmb.java b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
index e72a29f8ee..68d4744efe 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeAmb.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -30,7 +30,7 @@
  * @param <T> the value type
  */
 public final class OnSubscribeAmb<T> implements OnSubscribe<T>{
-    //give default access instead of private as a micro-optimization 
+    //give default access instead of private as a micro-optimization
     //for access from anonymous classes below
     final Iterable<? extends Observable<? extends T>> sources;
 
@@ -348,7 +348,7 @@ public void unsubscribeLosers() {
                 unsubscribeOthers(winner);
             }
         }
-        
+
         public void unsubscribeOthers(AmbSubscriber<T> notThis) {
             for (AmbSubscriber<T> other : ambSubscribers) {
                 if (other != notThis) {
@@ -359,7 +359,7 @@ public void unsubscribeOthers(AmbSubscriber<T> notThis) {
         }
 
     }
-    
+
     private OnSubscribeAmb(Iterable<? extends Observable<? extends T>> sources) {
         this.sources = sources;
     }
@@ -367,7 +367,7 @@ private OnSubscribeAmb(Iterable<? extends Observable<? extends T>> sources) {
     @Override
     public void call(final Subscriber<? super T> subscriber) {
         final Selection<T> selection = new Selection<T>();
-        
+
         //setup unsubscription of all the subscribers to the sources
         subscriber.add(Subscriptions.create(new Action0() {
 
@@ -377,16 +377,16 @@ public void call() {
                 if ((c = selection.get()) != null) {
                     // there is a single winner so we unsubscribe it
                     c.unsubscribe();
-                } 
+                }
                 // if we are racing with others still existing, we'll also unsubscribe them
-                // if subscriptions are occurring as this is happening then this call may not 
+                // if subscriptions are occurring as this is happening then this call may not
                 // unsubscribe everything. We protect ourselves though by doing another unsubscribe check
                 // after the subscription loop below
                 unsubscribeAmbSubscribers(selection.ambSubscribers);
             }
 
         }));
-        
+
         //need to subscribe to all the sources
         for (Observable<? extends T> source : sources) {
             if (subscriber.isUnsubscribed()) {
@@ -395,7 +395,7 @@ public void call() {
             AmbSubscriber<T> ambSubscriber = new AmbSubscriber<T>(0, subscriber, selection);
             selection.ambSubscribers.add(ambSubscriber);
             // check again if choice has been made so can stop subscribing
-            // if all sources were backpressure aware then this check 
+            // if all sources were backpressure aware then this check
             // would be pointless given that 0 was requested above from each ambSubscriber
             AmbSubscriber<T> c;
             if ((c = selection.get()) != null) {
@@ -422,12 +422,12 @@ public void request(long n) {
                     //propagate the request to all the amb subscribers
                     for (AmbSubscriber<T> ambSubscriber: selection.ambSubscribers) {
                         if (!ambSubscriber.isUnsubscribed()) {
-                            // make a best endeavours check to not waste requests 
+                            // make a best endeavours check to not waste requests
                             // if first emission has already occurred
                             if (selection.get() == ambSubscriber) {
                                 ambSubscriber.requestMore(n);
                                 // don't need to request from other subscribers because choice has been made
-                                // and request has gone to choice 
+                                // and request has gone to choice
                                 return;
                             } else {
                                 ambSubscriber.requestMore(n);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java b/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
index be1a5bc6c6..87a81ae7e8 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -32,11 +32,11 @@
 @SuppressWarnings("serial")
 public final class OnSubscribeAutoConnect<T> extends AtomicInteger implements OnSubscribe<T> {
     // AtomicInteger aspect of `this` represents the number of clients
-	
+
 	final ConnectableObservable<? extends T> source;
     final int numberOfSubscribers;
     final Action1<? super Subscription> connection;
-    
+
     public OnSubscribeAutoConnect(ConnectableObservable<? extends T> source,
             int numberOfSubscribers,
             Action1<? super Subscription> connection) {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeCollect.java b/src/main/java/rx/internal/operators/OnSubscribeCollect.java
index 94257e08c8..7577349d88 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeCollect.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeCollect.java
@@ -24,9 +24,9 @@
 public final class OnSubscribeCollect<T, R> implements OnSubscribe<R> {
 
     final Observable<T> source;
-    
+
     final Func0<R> collectionFactory;
-    
+
     final Action2<R, ? super T> collector;
 
     public OnSubscribeCollect(Observable<T> source, Func0<R> collectionFactory, Action2<R, ? super T> collector) {
@@ -34,11 +34,11 @@ public OnSubscribeCollect(Observable<T> source, Func0<R> collectionFactory, Acti
         this.collectionFactory = collectionFactory;
         this.collector = collector;
     }
-    
+
     @Override
     public void call(Subscriber<? super R> t) {
         R initialValue;
-        
+
         try {
             initialValue = collectionFactory.call();
         } catch (Throwable ex) {
@@ -46,10 +46,10 @@ public void call(Subscriber<? super R> t) {
             t.onError(ex);
             return;
         }
-        
+
         new CollectSubscriber<T, R>(t, initialValue, collector).subscribeTo(source);
     }
-    
+
     static final class CollectSubscriber<T, R> extends DeferredScalarSubscriberSafe<T, R> {
 
         final Action2<R, ? super T> collector;
@@ -74,6 +74,6 @@ public void onNext(T t) {
                 onError(ex);
             }
         }
-        
+
     }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
index 2d4f12f467..ef5bca4951 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
@@ -1,11 +1,11 @@
 /**
  * Copyright 2015 Netflix, Inc.
- * 
+ *
  * 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.
@@ -31,12 +31,12 @@ public final class OnSubscribeCombineLatest<T, R> implements OnSubscribe<R> {
     final FuncN<? extends R> combiner;
     final int bufferSize;
     final boolean delayError;
-    
+
     public OnSubscribeCombineLatest(Iterable<? extends Observable<? extends T>> sourcesIterable,
             FuncN<? extends R> combiner) {
         this(null, sourcesIterable, combiner, RxRingBuffer.SIZE, false);
     }
-    
+
     public OnSubscribeCombineLatest(Observable<? extends T>[] sources,
             Iterable<? extends Observable<? extends T>> sourcesIterable,
             FuncN<? extends R> combiner, int bufferSize,
@@ -48,7 +48,7 @@ public OnSubscribeCombineLatest(Observable<? extends T>[] sources,
         this.delayError = delayError;
     }
 
-    
+
     @Override
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public void call(Subscriber<? super R> s) {
@@ -74,16 +74,16 @@ public void call(Subscriber<? super R> s) {
         } else {
             count = sources.length;
         }
-        
+
         if (count == 0) {
             s.onCompleted();
             return;
         }
-        
+
         LatestCoordinator<T, R> lc = new LatestCoordinator<T, R>(s, combiner, count, bufferSize, delayError);
         lc.subscribe(sources);
     }
-    
+
     static final class LatestCoordinator<T, R> extends AtomicInteger implements Producer, Subscription {
         /** */
         private static final long serialVersionUID = 8567835998786448817L;
@@ -94,24 +94,24 @@ static final class LatestCoordinator<T, R> extends AtomicInteger implements Prod
         final Object[] latest;
         final SpscLinkedArrayQueue<Object> queue;
         final boolean delayError;
-        
+
         volatile boolean cancelled;
-        
+
         volatile boolean done;
-        
+
         final AtomicLong requested;
 
         final AtomicReference<Throwable> error;
-        
+
         int active;
         int complete;
-        
+
         /** Indicates the particular source hasn't emitted any value yet. */
         static final Object MISSING = new Object();
-        
+
         @SuppressWarnings("unchecked")
-        public LatestCoordinator(Subscriber<? super R> actual, 
-                FuncN<? extends R> combiner, 
+        public LatestCoordinator(Subscriber<? super R> actual,
+                FuncN<? extends R> combiner,
                 int count, int bufferSize, boolean delayError) {
             this.actual = actual;
             this.combiner = combiner;
@@ -124,7 +124,7 @@ public LatestCoordinator(Subscriber<? super R> actual,
             this.requested = new AtomicLong();
             this.error = new AtomicReference<Throwable>();
         }
-        
+
         @SuppressWarnings("unchecked")
         public void subscribe(Observable<? extends T>[] sources) {
             Subscriber<T>[] as = subscribers;
@@ -142,7 +142,7 @@ public void subscribe(Observable<? extends T>[] sources) {
                 ((Observable<T>)sources[i]).subscribe(as[i]);
             }
         }
-        
+
         @Override
         public void request(long n) {
             if (n < 0) {
@@ -153,30 +153,30 @@ public void request(long n) {
                 drain();
             }
         }
-        
+
         @Override
         public void unsubscribe() {
             if (!cancelled) {
                 cancelled = true;
-                
+
                 if (getAndIncrement() == 0) {
                     cancel(queue);
                 }
             }
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return cancelled;
         }
-        
+
         void cancel(Queue<?> q) {
             q.clear();
             for (CombinerSubscriber<T, R> s : subscribers) {
                 s.unsubscribe();
             }
         }
-        
+
         /**
          * Combine the given notification value from the indexth source with the existing known
          * latest values.
@@ -185,7 +185,7 @@ void cancel(Queue<?> q) {
          */
         void combine(Object value, int index) {
             CombinerSubscriber<T, R> combinerSubscriber = subscribers[index];
-            
+
             int activeCount;
             int completedCount;
             int sourceCount;
@@ -206,7 +206,7 @@ void combine(Object value, int index) {
                 }
                 allSourcesFinished = activeCount == sourceCount;
                 // see if either all sources completed
-                empty = completedCount == sourceCount 
+                empty = completedCount == sourceCount
                         || (value == null && o == MISSING); // or this source completed without any value
                 if (!empty) {
                     if (value != null && allSourcesFinished) {
@@ -229,47 +229,47 @@ void drain() {
             if (getAndIncrement() != 0) {
                 return;
             }
-            
+
             final Queue<Object> q = queue;
             final Subscriber<? super R> a = actual;
             final boolean delayError = this.delayError;
             final AtomicLong localRequested = this.requested;
-            
+
             int missed = 1;
             for (;;) {
-                
+
                 if (checkTerminated(done, q.isEmpty(), a, q, delayError)) {
                     return;
                 }
-                
+
                 long requestAmount = localRequested.get();
                 long emitted = 0L;
-                
+
                 while (emitted != requestAmount) {
-                    
+
                     boolean d = done;
                     @SuppressWarnings("unchecked")
                     CombinerSubscriber<T, R> cs = (CombinerSubscriber<T, R>)q.peek();
                     boolean empty = cs == null;
-                    
+
                     if (checkTerminated(d, empty, a, q, delayError)) {
                         return;
                     }
-                    
+
                     if (empty) {
                         break;
                     }
 
                     q.poll();
                     Object[] array = (Object[])q.poll();
-                    
+
                     if (array == null) {
                         cancelled = true;
                         cancel(q);
                         a.onError(new IllegalStateException("Broken queue?! Sender received but not the array."));
                         return;
                     }
-                    
+
                     R v;
                     try {
                         v = combiner.call(array);
@@ -279,26 +279,26 @@ void drain() {
                         a.onError(ex);
                         return;
                     }
-                    
+
                     a.onNext(v);
-                    
+
                     cs.requestMore(1);
-                    
+
                     emitted++;
                 }
-                
+
                 if (emitted != 0L && requestAmount != Long.MAX_VALUE) {
                     BackpressureUtils.produced(localRequested, emitted);
                 }
-                
+
                 missed = addAndGet(-missed);
                 if (missed == 0) {
                     break;
                 }
             }
         }
-        
-        
+
+
         boolean checkTerminated(boolean mainDone, boolean queueEmpty, Subscriber<?> childSubscriber, Queue<?> q, boolean delayError) {
             if (cancelled) {
                 cancel(q);
@@ -330,7 +330,7 @@ boolean checkTerminated(boolean mainDone, boolean queueEmpty, Subscriber<?> chil
             }
             return false;
         }
-        
+
         void onError(Throwable e) {
             AtomicReference<Throwable> localError = this.error;
             for (;;) {
@@ -354,21 +354,21 @@ void onError(Throwable e) {
             }
         }
     }
-    
+
     static final class CombinerSubscriber<T, R> extends Subscriber<T> {
         final LatestCoordinator<T, R> parent;
         final int index;
         final NotificationLite<T> nl;
-        
+
         boolean done;
-        
+
         public CombinerSubscriber(LatestCoordinator<T, R> parent, int index) {
             this.parent = parent;
             this.index = index;
             this.nl = NotificationLite.instance();
             request(parent.bufferSize);
         }
-        
+
         @Override
         public void onNext(T t) {
             if (done) {
@@ -376,7 +376,7 @@ public void onNext(T t) {
             }
             parent.combine(nl.next(t), index);
         }
-        
+
         @Override
         public void onError(Throwable t) {
             if (done) {
@@ -387,7 +387,7 @@ public void onError(Throwable t) {
             done = true;
             parent.combine(null, index);
         }
-        
+
         @Override
         public void onCompleted() {
             if (done) {
@@ -396,7 +396,7 @@ public void onCompleted() {
             done = true;
             parent.combine(null, index);
         }
-        
+
         public void requestMore(long n) {
             request(n);
         }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java b/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java
index fba34e2f6b..c12643f123 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java
@@ -36,28 +36,28 @@
  * to one at a time.
  * @param <T> the source value type
  * @param <R> the output value type
- * 
+ *
  * @since 1.1.2
  */
 public final class OnSubscribeConcatMap<T, R> implements OnSubscribe<R> {
     final Observable<? extends T> source;
-    
+
     final Func1<? super T, ? extends Observable<? extends R>> mapper;
-    
+
     final int prefetch;
-    
-    /** 
+
+    /**
      * How to handle errors from the main and inner Observables.
      * See the constants below.
      */
     final int delayErrorMode;
-    
+
     /** Whenever any Observable fires an error, terminate with that error immediately. */
     public static final int IMMEDIATE = 0;
-    
+
     /** Whenever the main fires an error, wait until the inner terminates. */
     public static final int BOUNDARY = 1;
-    
+
     /** Delay all errors to the very end. */
     public static final int END = 2;
 
@@ -68,19 +68,19 @@ public OnSubscribeConcatMap(Observable<? extends T> source, Func1<? super T, ? e
         this.prefetch = prefetch;
         this.delayErrorMode = delayErrorMode;
     }
-    
+
     @Override
     public void call(Subscriber<? super R> child) {
         Subscriber<? super R> s;
-        
+
         if (delayErrorMode == IMMEDIATE) {
             s = new SerializedSubscriber<R>(child);
         } else {
             s = child;
         }
-        
+
         final ConcatMapSubscriber<T, R> parent = new ConcatMapSubscriber<T, R>(s, mapper, prefetch, delayErrorMode);
-        
+
         child.add(parent);
         child.add(parent.inner);
         child.setProducer(new Producer() {
@@ -89,31 +89,31 @@ public void request(long n) {
                 parent.requestMore(n);
             }
         });
-        
+
         if (!child.isUnsubscribed()) {
             source.unsafeSubscribe(parent);
         }
     }
-    
+
     static final class ConcatMapSubscriber<T, R> extends Subscriber<T> {
         final Subscriber<? super R> actual;
-        
+
         final Func1<? super T, ? extends Observable<? extends R>> mapper;
-        
+
         final int delayErrorMode;
-        
+
         final ProducerArbiter arbiter;
-        
+
         final Queue<Object> queue;
-        
+
         final AtomicInteger wip;
-        
+
         final AtomicReference<Throwable> error;
-        
+
         final SerialSubscription inner;
-        
+
         volatile boolean done;
-        
+
         volatile boolean active;
 
         public ConcatMapSubscriber(Subscriber<? super R> actual,
@@ -144,7 +144,7 @@ public void onNext(T t) {
                 drain();
             }
         }
-        
+
         @Override
         public void onError(Throwable mainError) {
             if (ExceptionsUtils.addThrowable(error, mainError)) {
@@ -162,13 +162,13 @@ public void onError(Throwable mainError) {
                 pluginError(mainError);
             }
         }
-        
+
         @Override
         public void onCompleted() {
             done = true;
             drain();
         }
-        
+
         void requestMore(long n) {
             if (n > 0) {
                 arbiter.request(n);
@@ -177,11 +177,11 @@ void requestMore(long n) {
                 throw new IllegalArgumentException("n >= 0 required but it was " + n);
             }
         }
-        
+
         void innerNext(R value) {
             actual.onNext(value);
         }
-        
+
         void innerError(Throwable innerError, long produced) {
             if (!ExceptionsUtils.addThrowable(error, innerError)) {
                 pluginError(innerError);
@@ -200,7 +200,7 @@ void innerError(Throwable innerError, long produced) {
                 drain();
             }
         }
-        
+
         void innerCompleted(long produced) {
             if (produced != 0L) {
                 arbiter.produced(produced);
@@ -208,23 +208,23 @@ void innerCompleted(long produced) {
             active = false;
             drain();
         }
-        
+
         void pluginError(Throwable e) {
             RxJavaHooks.onError(e);
         }
-        
+
         void drain() {
             if (wip.getAndIncrement() != 0) {
                 return;
             }
 
             final int delayErrorMode = this.delayErrorMode;
-            
+
             for (;;) {
                 if (actual.isUnsubscribed()) {
                     return;
                 }
-                
+
                 if (!active) {
                     if (delayErrorMode == BOUNDARY) {
                         if (error.get() != null) {
@@ -235,11 +235,11 @@ void drain() {
                             return;
                         }
                     }
-                    
+
                     boolean mainDone = done;
                     Object v = queue.poll();
                     boolean empty = v == null;
-                    
+
                     if (mainDone && empty) {
                         Throwable ex = ExceptionsUtils.terminate(error);
                         if (ex == null) {
@@ -250,11 +250,11 @@ void drain() {
                         }
                         return;
                     }
-                    
+
                     if (!empty) {
-                        
+
                         Observable<? extends R> source;
-                        
+
                         try {
                             source = mapper.call(NotificationLite.<T>instance().getValue(v));
                         } catch (Throwable mapperError) {
@@ -262,27 +262,27 @@ void drain() {
                             drainError(mapperError);
                             return;
                         }
-                        
+
                         if (source == null) {
                             drainError(new NullPointerException("The source returned by the mapper was null"));
                             return;
                         }
-                        
+
                         if (source != Observable.empty()) {
 
                             if (source instanceof ScalarSynchronousObservable) {
                                 ScalarSynchronousObservable<? extends R> scalarSource = (ScalarSynchronousObservable<? extends R>) source;
-                                
+
                                 active = true;
-                                
+
                                 arbiter.setProducer(new ConcatMapInnerScalarProducer<T, R>(scalarSource.get(), this));
                             } else {
                                 ConcatMapInnerSubscriber<T, R> innerSubscriber = new ConcatMapInnerSubscriber<T, R>(this);
                                 inner.set(innerSubscriber);
-        
+
                                 if (!innerSubscriber.isUnsubscribed()) {
                                     active = true;
-    
+
                                     source.unsafeSubscribe(innerSubscriber);
                                 } else {
                                     return;
@@ -300,10 +300,10 @@ void drain() {
                 }
             }
         }
-        
+
         void drainError(Throwable mapperError) {
             unsubscribe();
-            
+
             if (ExceptionsUtils.addThrowable(error, mapperError)) {
                 Throwable ex = ExceptionsUtils.terminate(error);
                 if (!ExceptionsUtils.isTerminated(ex)) {
@@ -314,43 +314,43 @@ void drainError(Throwable mapperError) {
             }
         }
     }
-    
+
     static final class ConcatMapInnerSubscriber<T, R> extends Subscriber<R> {
         final ConcatMapSubscriber<T, R> parent;
 
         long produced;
-        
+
         public ConcatMapInnerSubscriber(ConcatMapSubscriber<T, R> parent) {
             this.parent = parent;
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             parent.arbiter.setProducer(p);
         }
-        
+
         @Override
         public void onNext(R t) {
             produced++;
             parent.innerNext(t);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             parent.innerError(e, produced);
         }
-        
+
         @Override
         public void onCompleted() {
             parent.innerCompleted(produced);
         }
     }
-    
+
     static final class ConcatMapInnerScalarProducer<T, R> implements Producer {
         final R value;
-        
+
         final ConcatMapSubscriber<T, R> parent;
-        
+
         boolean once;
 
         public ConcatMapInnerScalarProducer(R value, ConcatMapSubscriber<T, R> parent) {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDefer.java b/src/main/java/rx/internal/operators/OnSubscribeDefer.java
index 35b278b682..985e149f98 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDefer.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDefer.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -50,5 +50,5 @@ public void call(final Subscriber<? super T> s) {
         }
         o.unsafeSubscribe(Subscribers.wrap(s));
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscription.java b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscription.java
index 1876db73a3..367b675413 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscription.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscription.java
@@ -25,7 +25,7 @@
 
 /**
  * Delays the subscription to the source by the given amount, running on the given scheduler.
- * 
+ *
  * @param <T> the value type
  */
 public final class OnSubscribeDelaySubscription<T> implements OnSubscribe<T> {
@@ -55,5 +55,5 @@ public void call() {
             }
         }, time, unit);
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java
index a9ae84b7ef..04658d8a4d 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionOther.java
@@ -31,28 +31,28 @@
 public final class OnSubscribeDelaySubscriptionOther<T, U> implements OnSubscribe<T> {
     final Observable<? extends T> main;
     final Observable<U> other;
-    
+
     public OnSubscribeDelaySubscriptionOther(Observable<? extends T> main, Observable<U> other) {
         this.main = main;
         this.other = other;
     }
-    
+
     @Override
     public void call(Subscriber<? super T> t) {
         final SerialSubscription serial = new SerialSubscription();
-        
+
         t.add(serial);
-        
+
         final Subscriber<T> child = Subscribers.wrap(t);
-        
-        
+
+
         Subscriber<U> otherSubscriber = new Subscriber<U>() {
             boolean done;
             @Override
             public void onNext(U t) {
                 onCompleted();
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 if (done) {
@@ -62,7 +62,7 @@ public void onError(Throwable e) {
                 done = true;
                 child.onError(e);
             }
-            
+
             @Override
             public void onCompleted() {
                 if (done) {
@@ -70,13 +70,13 @@ public void onCompleted() {
                 }
                 done = true;
                 serial.set(Subscriptions.unsubscribed());
-                
+
                 main.unsafeSubscribe(child);
             }
         };
-        
+
         serial.set(otherSubscriber);
-        
+
         other.unsafeSubscribe(otherSubscriber);
     }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionWithSelector.java b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionWithSelector.java
index 6b3fb02d62..3de8140731 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionWithSelector.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDelaySubscriptionWithSelector.java
@@ -23,7 +23,7 @@
 
 /**
  * Delays the subscription until the Observable<U> emits an event.
- * 
+ *
  * @param <T>
  *            the value type
  * @param <U> the value type of the Observable triggering the delayed subscription
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDetach.java b/src/main/java/rx/internal/operators/OnSubscribeDetach.java
index d883b6c49f..612247aeeb 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDetach.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDetach.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -22,39 +22,39 @@
 import rx.plugins.RxJavaHooks;
 
 /**
- * Nulls out references to upstream data structures when the source terminates or 
+ * Nulls out references to upstream data structures when the source terminates or
  * the child unsubscribes.
  * @param <T> the value type
  */
 public final class OnSubscribeDetach<T> implements OnSubscribe<T> {
-    
+
     final Observable<T> source;
-    
+
     public OnSubscribeDetach(Observable<T> source) {
         this.source = source;
     }
-    
+
     @Override
     public void call(Subscriber<? super T> t) {
         DetachSubscriber<T> parent = new DetachSubscriber<T>(t);
         DetachProducer<T> producer = new DetachProducer<T>(parent);
-        
+
         t.add(producer);
         t.setProducer(producer);
-        
+
         source.unsafeSubscribe(parent);
     }
-    
+
     /**
      * The parent subscriber that forwards events and cleans up on a terminal state.
      * @param <T> the value type
      */
     static final class DetachSubscriber<T> extends Subscriber<T> {
-        
+
         final AtomicReference<Subscriber<? super T>> actual;
-        
+
         final AtomicReference<Producer> producer;
-        
+
         final AtomicLong requested;
 
         public DetachSubscriber(Subscriber<? super T> actual) {
@@ -62,11 +62,11 @@ public DetachSubscriber(Subscriber<? super T> actual) {
             this.producer = new AtomicReference<Producer>();
             this.requested = new AtomicLong();
         }
-        
+
         @Override
         public void onNext(T t) {
             Subscriber<? super T> a = actual.get();
-            
+
             if (a != null) {
                 a.onNext(t);
             }
@@ -76,7 +76,7 @@ public void onNext(T t) {
         public void onError(Throwable e) {
             producer.lazySet(TerminatedProducer.INSTANCE);
             Subscriber<? super T> a = actual.getAndSet(null);
-            
+
             if (a != null) {
                 a.onError(e);
             } else {
@@ -84,17 +84,17 @@ public void onError(Throwable e) {
             }
         }
 
-        
+
         @Override
         public void onCompleted() {
             producer.lazySet(TerminatedProducer.INSTANCE);
             Subscriber<? super T> a = actual.getAndSet(null);
-            
+
             if (a != null) {
                 a.onCompleted();
             }
         }
-        
+
         void innerRequest(long n) {
             if (n < 0L) {
                 throw new IllegalArgumentException("n >= 0 required but it was " + n);
@@ -111,7 +111,7 @@ void innerRequest(long n) {
                 }
             }
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             if (producer.compareAndSet(null, p)) {
@@ -123,7 +123,7 @@ public void setProducer(Producer p) {
                 }
             }
         }
-        
+
         void innerUnsubscribe() {
             producer.lazySet(TerminatedProducer.INSTANCE);
             actual.lazySet(null);
@@ -131,7 +131,7 @@ void innerUnsubscribe() {
             unsubscribe();
         }
     }
-    
+
     /**
      * Callbacks from the child Subscriber.
      * @param <T> the value type
@@ -142,29 +142,29 @@ static final class DetachProducer<T> implements Producer, Subscription {
         public DetachProducer(DetachSubscriber<T> parent) {
             this.parent = parent;
         }
-        
+
         @Override
         public void request(long n) {
             parent.innerRequest(n);
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return parent.isUnsubscribed();
         }
-        
+
         @Override
         public void unsubscribe() {
             parent.innerUnsubscribe();
         }
     }
-    
+
     /**
      * Singleton instance via enum.
      */
     enum TerminatedProducer implements Producer {
         INSTANCE;
-        
+
         @Override
         public void request(long n) {
             // ignored
diff --git a/src/main/java/rx/internal/operators/OnSubscribeDoOnEach.java b/src/main/java/rx/internal/operators/OnSubscribeDoOnEach.java
index 34694ed311..8301d570c6 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeDoOnEach.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeDoOnEach.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -24,7 +24,7 @@
 
 /**
  * Calls specified actions for each notification.
- * 
+ *
  * @param <T> the value type
  */
 public class OnSubscribeDoOnEach<T> implements OnSubscribe<T> {
@@ -40,12 +40,12 @@ public OnSubscribeDoOnEach(Observable<T> source, Observer<? super T> doOnEachObs
     public void call(final Subscriber<? super T> subscriber) {
         source.unsafeSubscribe(new DoOnEachSubscriber<T>(subscriber, doOnEachObserver));
     }
-    
+
     private static final class DoOnEachSubscriber<T> extends Subscriber<T> {
 
         private final Subscriber<? super T> subscriber;
         private final Observer<? super T> doOnEachObserver;
-        
+
         private boolean done;
 
         DoOnEachSubscriber(Subscriber<? super T> subscriber, Observer<? super T> doOnEachObserver) {
@@ -99,6 +99,6 @@ public void onNext(T value) {
                 return;
             }
             subscriber.onNext(value);
-        }        
+        }
     }
 }
\ No newline at end of file
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFilter.java b/src/main/java/rx/internal/operators/OnSubscribeFilter.java
index cc0b4f63bc..d0edec3de3 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFilter.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFilter.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -30,7 +30,7 @@
 public final class OnSubscribeFilter<T> implements OnSubscribe<T> {
 
     final Observable<T> source;
-    
+
     final Func1<? super T, Boolean> predicate;
 
     public OnSubscribeFilter(Observable<T> source, Func1<? super T, Boolean> predicate) {
@@ -46,23 +46,23 @@ public void call(final Subscriber<? super T> child) {
     }
 
     static final class FilterSubscriber<T> extends Subscriber<T> {
-        
+
         final Subscriber<? super T> actual;
-        
+
         final Func1<? super T, Boolean> predicate;
 
         boolean done;
-        
+
         public FilterSubscriber(Subscriber<? super T> actual, Func1<? super T, Boolean> predicate) {
             this.actual = actual;
             this.predicate = predicate;
             request(0);
         }
-        
+
         @Override
         public void onNext(T t) {
             boolean result;
-            
+
             try {
                 result = predicate.call(t);
             } catch (Throwable ex) {
@@ -71,14 +71,14 @@ public void onNext(T t) {
                 onError(OnErrorThrowable.addValueAsLastCause(ex, t));
                 return;
             }
-            
+
             if (result) {
                 actual.onNext(t);
             } else {
                 request(1);
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             if (done) {
@@ -86,11 +86,11 @@ public void onError(Throwable e) {
                 return;
             }
             done = true;
-            
+
             actual.onError(e);
         }
-        
-        
+
+
         @Override
         public void onCompleted() {
             if (done) {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
index 9a0c907060..26b5390c13 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -36,13 +36,13 @@
  * @param <R> the output value type
  */
 public final class OnSubscribeFlattenIterable<T, R> implements OnSubscribe<R> {
-    
+
     final Observable<? extends T> source;
-    
+
     final Func1<? super T, ? extends Iterable<? extends R>> mapper;
-    
+
     final int prefetch;
-    
+
     /** Protected: use createFrom to handle source-dependent optimizations. */
     protected OnSubscribeFlattenIterable(Observable<? extends T> source,
             Func1<? super T, ? extends Iterable<? extends R>> mapper, int prefetch) {
@@ -50,11 +50,11 @@ protected OnSubscribeFlattenIterable(Observable<? extends T> source,
         this.mapper = mapper;
         this.prefetch = prefetch;
     }
-    
+
     @Override
     public void call(Subscriber<? super R> t) {
         final FlattenIterableSubscriber<T, R> parent = new FlattenIterableSubscriber<T, R>(t, mapper, prefetch);
-        
+
         t.add(parent);
         t.setProducer(new Producer() {
             @Override
@@ -62,10 +62,10 @@ public void request(long n) {
                 parent.requestMore(n);
             }
         });
-        
+
         source.unsafeSubscribe(parent);
     }
-    
+
     public static <T, R> Observable<R> createFrom(Observable<? extends T> source,
             Func1<? super T, ? extends Iterable<? extends R>> mapper, int prefetch) {
         if (source instanceof ScalarSynchronousObservable) {
@@ -74,30 +74,30 @@ public static <T, R> Observable<R> createFrom(Observable<? extends T> source,
         }
         return Observable.create(new OnSubscribeFlattenIterable<T, R>(source, mapper, prefetch));
     }
-    
+
     static final class FlattenIterableSubscriber<T, R> extends Subscriber<T> {
         final Subscriber<? super R> actual;
-        
+
         final Func1<? super T, ? extends Iterable<? extends R>> mapper;
-        
+
         final long limit;
-        
+
         final Queue<Object> queue;
 
         final AtomicReference<Throwable> error;
-        
+
         final AtomicLong requested;
-        
+
         final AtomicInteger wip;
-        
+
         final NotificationLite<T> nl;
-        
+
         volatile boolean done;
-        
+
         long produced;
-        
+
         Iterator<? extends R> active;
-        
+
         public FlattenIterableSubscriber(Subscriber<? super R> actual,
                 Func1<? super T, ? extends Iterable<? extends R>> mapper, int prefetch) {
             this.actual = actual;
@@ -120,7 +120,7 @@ public FlattenIterableSubscriber(Subscriber<? super R> actual,
             }
             request(prefetch);
         }
-        
+
         @Override
         public void onNext(T t) {
             if (!queue.offer(nl.next(t))) {
@@ -130,7 +130,7 @@ public void onNext(T t) {
             }
             drain();
         }
-        
+
         @Override
         public void onError(Throwable e) {
             if (ExceptionsUtils.addThrowable(error, e)) {
@@ -140,13 +140,13 @@ public void onError(Throwable e) {
                 RxJavaHooks.onError(e);
             }
         }
-        
+
         @Override
         public void onCompleted() {
             done = true;
             drain();
         }
-        
+
         void requestMore(long n) {
             if (n > 0) {
                 BackpressureUtils.getAndAddRequest(requested, n);
@@ -155,34 +155,34 @@ void requestMore(long n) {
                 throw new IllegalStateException("n >= 0 required but it was " + n);
             }
         }
-        
+
         void drain() {
             if (wip.getAndIncrement() != 0) {
                 return;
             }
-            
+
             final Subscriber<? super R> actual = this.actual;
             final Queue<Object> queue = this.queue;
-            
+
             int missed = 1;
-            
+
             for (;;) {
-                
+
                 Iterator<? extends R> it = active;
-                
+
                 if (it == null) {
                     boolean d = done;
-                    
+
                     Object v = queue.poll();
-                    
+
                     boolean empty = v == null;
 
                     if (checkTerminated(d, empty, actual, queue)) {
                         return;
                     }
-                    
+
                     if (!empty) {
-                    
+
                         long p = produced + 1;
                         if (p == limit) {
                             produced = 0L;
@@ -190,43 +190,43 @@ void drain() {
                         } else {
                             produced = p;
                         }
-                        
+
                         boolean b;
-                        
+
                         try {
                             Iterable<? extends R> iter = mapper.call(nl.getValue(v));
-                            
+
                             it = iter.iterator();
-                            
+
                             b = it.hasNext();
                         } catch (Throwable ex) {
                             Exceptions.throwIfFatal(ex);
-                            
+
                             it = null;
                             onError(ex);
-                            
+
                             continue;
                         }
-                        
+
                         if (!b) {
                             continue;
                         }
-                        
+
                         active = it;
                     }
                 }
-                
+
                 if (it != null) {
                     long r = requested.get();
                     long e = 0L;
-                    
+
                     while (e != r) {
                         if (checkTerminated(done, false, actual, queue)) {
                             return;
                         }
-                        
+
                         R v;
-                        
+
                         try {
                             v = it.next();
                         } catch (Throwable ex) {
@@ -236,7 +236,7 @@ void drain() {
                             onError(ex);
                             break;
                         }
-                        
+
                         actual.onNext(v);
 
                         if (checkTerminated(done, false, actual, queue)) {
@@ -246,7 +246,7 @@ void drain() {
                         e++;
 
                         boolean b;
-                        
+
                         try {
                             b = it.hasNext();
                         } catch (Throwable ex) {
@@ -256,43 +256,43 @@ void drain() {
                             onError(ex);
                             break;
                         }
-                        
+
                         if (!b) {
                             it = null;
                             active = null;
                             break;
                         }
                     }
-                    
+
                     if (e == r) {
                         if (checkTerminated(done, queue.isEmpty() && it == null, actual, queue)) {
                             return;
                         }
                     }
-                    
+
                     if (e != 0L) {
                         BackpressureUtils.produced(requested, e);
                     }
-                    
+
                     if (it == null) {
                         continue;
                     }
                 }
-                
+
                 missed = wip.addAndGet(-missed);
                 if (missed == 0) {
                     break;
                 }
             }
         }
-        
+
         boolean checkTerminated(boolean d, boolean empty, Subscriber<?> a, Queue<?> q) {
             if (a.isUnsubscribed()) {
                 q.clear();
                 active = null;
                 return true;
             }
-            
+
             if (d) {
                 Throwable ex = error.get();
                 if (ex != null) {
@@ -300,21 +300,21 @@ boolean checkTerminated(boolean d, boolean empty, Subscriber<?> a, Queue<?> q) {
                     unsubscribe();
                     q.clear();
                     active = null;
-                    
+
                     a.onError(ex);
                     return true;
                 } else
                 if (empty) {
-                    
+
                     a.onCompleted();
                     return true;
                 }
             }
-            
+
             return false;
         }
     }
-    
+
     /**
      * A custom flattener that works from a scalar value and computes the iterable
      * during subscription time.
@@ -324,7 +324,7 @@ boolean checkTerminated(boolean d, boolean empty, Subscriber<?> a, Queue<?> q) {
      */
     static final class OnSubscribeScalarFlattenIterable<T, R> implements OnSubscribe<R> {
         final T value;
-        
+
         final Func1<? super T, ? extends Iterable<? extends R>> mapper;
 
         public OnSubscribeScalarFlattenIterable(T value, Func1<? super T, ? extends Iterable<? extends R>> mapper) {
@@ -338,20 +338,20 @@ public void call(Subscriber<? super R> t) {
             boolean b;
             try {
                 Iterable<? extends R> it = mapper.call(value);
-                
+
                 itor = it.iterator();
-                
+
                 b = itor.hasNext();
             } catch (Throwable ex) {
                 Exceptions.throwOrReport(ex, t, value);
                 return;
             }
-            
+
             if (!b) {
                 t.onCompleted();
                 return;
             }
-            
+
             t.setProducer(new OnSubscribeFromIterable.IterableProducer<R>(t, itor));
         }
     }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromArray.java b/src/main/java/rx/internal/operators/OnSubscribeFromArray.java
index 623dcaa65f..3039fc0188 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromArray.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromArray.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -26,28 +26,28 @@ public final class OnSubscribeFromArray<T> implements OnSubscribe<T> {
     public OnSubscribeFromArray(T[] array) {
         this.array = array;
     }
-    
+
     @Override
     public void call(Subscriber<? super T> child) {
         child.setProducer(new FromArrayProducer<T>(child, array));
     }
-    
+
     static final class FromArrayProducer<T>
     extends AtomicLong
     implements Producer {
         /** */
         private static final long serialVersionUID = 3534218984725836979L;
-        
+
         final Subscriber<? super T> child;
         final T[] array;
-        
+
         int index;
-        
+
         public FromArrayProducer(Subscriber<? super T> child, T[] array) {
             this.child = child;
             this.array = array;
         }
-        
+
         @Override
         public void request(long n) {
             if (n < 0) {
@@ -64,56 +64,56 @@ public void request(long n) {
                 }
             }
         }
-        
+
         void fastPath() {
             final Subscriber<? super T> child = this.child;
-            
+
             for (T t : array) {
                 if (child.isUnsubscribed()) {
                     return;
                 }
-                
+
                 child.onNext(t);
             }
-            
+
             if (child.isUnsubscribed()) {
                 return;
             }
             child.onCompleted();
         }
-        
+
         void slowPath(long r) {
             final Subscriber<? super T> child = this.child;
             final T[] array = this.array;
             final int n = array.length;
-            
+
             long e = 0L;
             int i = index;
 
             for (;;) {
-                
+
                 while (r != 0L && i != n) {
                     if (child.isUnsubscribed()) {
                         return;
                     }
-                    
+
                     child.onNext(array[i]);
-                    
+
                     i++;
-                    
+
                     if (i == n) {
                         if (!child.isUnsubscribed()) {
                             child.onCompleted();
                         }
                         return;
                     }
-                    
+
                     r--;
                     e--;
                 }
-                
+
                 r = get() + e;
-                
+
                 if (r == 0L) {
                     index = i;
                     r = addAndGet(e);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java b/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
index a911a9d09d..68bfb4ccbf 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -31,18 +31,18 @@
 public final class OnSubscribeFromEmitter<T> implements OnSubscribe<T> {
 
     final Action1<AsyncEmitter<T>> asyncEmitter;
-    
+
     final AsyncEmitter.BackpressureMode backpressure;
-    
+
     public OnSubscribeFromEmitter(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) {
         this.asyncEmitter = asyncEmitter;
         this.backpressure = backpressure;
     }
-    
+
     @Override
     public void call(Subscriber<? super T> t) {
         BaseAsyncEmitter<T> emitter;
-        
+
         switch (backpressure) {
         case NONE: {
             emitter = new NoneAsyncEmitter<T>(t);
@@ -69,28 +69,28 @@ public void call(Subscriber<? super T> t) {
         t.add(emitter);
         t.setProducer(emitter);
         asyncEmitter.call(emitter);
-        
+
     }
-    
+
     /**
      * A Subscription that wraps an AsyncEmitter.Cancellable instance.
      */
-    static final class CancellableSubscription 
+    static final class CancellableSubscription
     extends AtomicReference<AsyncEmitter.Cancellable>
     implements Subscription {
-        
+
         /** */
         private static final long serialVersionUID = 5718521705281392066L;
 
         public CancellableSubscription(AsyncEmitter.Cancellable cancellable) {
             super(cancellable);
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return get() == null;
         }
-        
+
         @Override
         public void unsubscribe() {
             if (get() != null) {
@@ -106,15 +106,15 @@ public void unsubscribe() {
             }
         }
     }
-    
-    static abstract class BaseAsyncEmitter<T> 
+
+    static abstract class BaseAsyncEmitter<T>
     extends AtomicLong
     implements AsyncEmitter<T>, Producer, Subscription {
         /** */
         private static final long serialVersionUID = 7326289992464377023L;
 
         final Subscriber<? super T> actual;
-        
+
         final SerialSubscription serial;
 
         public BaseAsyncEmitter(Subscriber<? super T> actual) {
@@ -151,7 +151,7 @@ public final void unsubscribe() {
             serial.unsubscribe();
             onUnsubscribed();
         }
-        
+
         void onUnsubscribed() {
             // default is no-op
         }
@@ -172,7 +172,7 @@ public final void request(long n) {
         void onRequested() {
             // default is no-op
         }
-        
+
         @Override
         public final void setSubscription(Subscription s) {
             serial.set(s);
@@ -188,7 +188,7 @@ public final long requested() {
             return get();
         }
     }
-    
+
     static final class NoneAsyncEmitter<T> extends BaseAsyncEmitter<T> {
 
         /** */
@@ -205,7 +205,7 @@ public void onNext(T t) {
             }
 
             actual.onNext(t);
-            
+
             for (;;) {
                 long r = get();
                 if (r == 0L || compareAndSet(r, r - 1)) {
@@ -215,7 +215,7 @@ public void onNext(T t) {
         }
 
     }
-    
+
     static abstract class NoOverflowBaseAsyncEmitter<T> extends BaseAsyncEmitter<T> {
 
         /** */
@@ -238,10 +238,10 @@ public void onNext(T t) {
                 onOverflow();
             }
         }
-        
+
         abstract void onOverflow();
     }
-    
+
     static final class DropAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
 
         /** */
@@ -255,20 +255,20 @@ public DropAsyncEmitter(Subscriber<? super T> actual) {
         void onOverflow() {
             // nothing to do
         }
-        
+
     }
 
     static final class ErrorAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
 
         /** */
         private static final long serialVersionUID = 338953216916120960L;
-        
+
         private boolean done;
 
         public ErrorAsyncEmitter(Subscriber<? super T> actual) {
             super(actual);
         }
-        
+
 
         @Override
         public void onNext(T t) {
@@ -304,26 +304,26 @@ public void onError(Throwable e) {
         void onOverflow() {
             onError(new MissingBackpressureException("fromEmitter: could not emit value due to lack of requests"));
         }
-        
+
     }
-    
+
     static final class BufferAsyncEmitter<T> extends BaseAsyncEmitter<T> {
 
         /** */
         private static final long serialVersionUID = 2427151001689639875L;
 
         final Queue<Object> queue;
-        
+
         Throwable error;
         volatile boolean done;
-        
+
         final AtomicInteger wip;
-        
+
         final NotificationLite<T> nl;
-        
+
         public BufferAsyncEmitter(Subscriber<? super T> actual, int capacityHint) {
             super(actual);
-            this.queue = UnsafeAccess.isUnsafeAvailable() 
+            this.queue = UnsafeAccess.isUnsafeAvailable()
                     ? new SpscUnboundedArrayQueue<Object>(capacityHint)
                     : new SpscUnboundedAtomicArrayQueue<Object>(capacityHint);
             this.wip = new AtomicInteger();
@@ -335,7 +335,7 @@ public void onNext(T t) {
             queue.offer(nl.next(t));
             drain();
         }
-        
+
         @Override
         public void onError(Throwable e) {
             error = e;
@@ -348,7 +348,7 @@ public void onCompleted() {
             done = true;
             drain();
         }
-        
+
         @Override
         void onRequested() {
             drain();
@@ -360,32 +360,32 @@ void onUnsubscribed() {
                 queue.clear();
             }
         }
-        
+
         void drain() {
             if (wip.getAndIncrement() != 0) {
                 return;
             }
-            
+
             int missed = 1;
             final Subscriber<? super T> a = actual;
             final Queue<Object> q = queue;
-            
+
             for (;;) {
                 long r = get();
                 long e = 0L;
-                
+
                 while (e != r) {
                     if (a.isUnsubscribed()) {
                         q.clear();
                         return;
                     }
-                    
+
                     boolean d = done;
-                    
+
                     Object o = q.poll();
-                    
+
                     boolean empty = o == null;
-                    
+
                     if (d && empty) {
                         Throwable ex = error;
                         if (ex != null) {
@@ -395,26 +395,26 @@ void drain() {
                         }
                         return;
                     }
-                    
+
                     if (empty) {
                         break;
                     }
-                    
+
                     a.onNext(nl.getValue(o));
-                    
+
                     e++;
                 }
-                
+
                 if (e == r) {
                     if (a.isUnsubscribed()) {
                         q.clear();
                         return;
                     }
-                    
+
                     boolean d = done;
-                    
+
                     boolean empty = q.isEmpty();
-                    
+
                     if (d && empty) {
                         Throwable ex = error;
                         if (ex != null) {
@@ -425,11 +425,11 @@ void drain() {
                         return;
                     }
                 }
-                
+
                 if (e != 0) {
                     BackpressureUtils.produced(this, e);
                 }
-                
+
                 missed = wip.addAndGet(-missed);
                 if (missed == 0) {
                     break;
@@ -447,11 +447,11 @@ static final class LatestAsyncEmitter<T> extends BaseAsyncEmitter<T> {
 
         Throwable error;
         volatile boolean done;
-        
+
         final AtomicInteger wip;
-        
+
         final NotificationLite<T> nl;
-        
+
         public LatestAsyncEmitter(Subscriber<? super T> actual) {
             super(actual);
             this.queue = new AtomicReference<Object>();
@@ -464,7 +464,7 @@ public void onNext(T t) {
             queue.set(nl.next(t));
             drain();
         }
-        
+
         @Override
         public void onError(Throwable e) {
             error = e;
@@ -477,7 +477,7 @@ public void onCompleted() {
             done = true;
             drain();
         }
-        
+
         @Override
         void onRequested() {
             drain();
@@ -489,32 +489,32 @@ void onUnsubscribed() {
                 queue.lazySet(null);
             }
         }
-        
+
         void drain() {
             if (wip.getAndIncrement() != 0) {
                 return;
             }
-            
+
             int missed = 1;
             final Subscriber<? super T> a = actual;
             final AtomicReference<Object> q = queue;
-            
+
             for (;;) {
                 long r = get();
                 long e = 0L;
-                
+
                 while (e != r) {
                     if (a.isUnsubscribed()) {
                         q.lazySet(null);
                         return;
                     }
-                    
+
                     boolean d = done;
-                    
+
                     Object o = q.getAndSet(null);
-                    
+
                     boolean empty = o == null;
-                    
+
                     if (d && empty) {
                         Throwable ex = error;
                         if (ex != null) {
@@ -524,26 +524,26 @@ void drain() {
                         }
                         return;
                     }
-                    
+
                     if (empty) {
                         break;
                     }
-                    
+
                     a.onNext(nl.getValue(o));
-                    
+
                     e++;
                 }
-                
+
                 if (e == r) {
                     if (a.isUnsubscribed()) {
                         q.lazySet(null);
                         return;
                     }
-                    
+
                     boolean d = done;
-                    
+
                     boolean empty = q.get() == null;
-                    
+
                     if (d && empty) {
                         Throwable ex = error;
                         if (ex != null) {
@@ -554,11 +554,11 @@ void drain() {
                         return;
                     }
                 }
-                
+
                 if (e != 0) {
                     BackpressureUtils.produced(this, e);
                 }
-                
+
                 missed = wip.addAndGet(-missed);
                 if (missed == 0) {
                     break;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java b/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
index 889cce2872..9bc9f31a9e 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -46,20 +46,20 @@ public OnSubscribeFromIterable(Iterable<? extends T> iterable) {
     public void call(final Subscriber<? super T> o) {
         Iterator<? extends T> it;
         boolean b;
-        
+
         try {
             it = is.iterator();
-            
+
             b = it.hasNext();
         } catch (Throwable ex) {
             Exceptions.throwOrReport(ex, o);
             return;
         }
-            
+
         if (!o.isUnsubscribed()) {
             if (!b) {
                 o.onCompleted();
-            } else { 
+            } else {
                 o.setProducer(new IterableProducer<T>(o, it));
             }
         }
@@ -84,7 +84,7 @@ public void request(long n) {
             }
             if (n == Long.MAX_VALUE && compareAndSet(0, Long.MAX_VALUE)) {
                 fastpath();
-            } else 
+            } else
             if (n > 0 && BackpressureUtils.getAndAddRequest(this, n) == 0L) {
                 slowpath(n);
             }
@@ -98,22 +98,22 @@ void slowpath(long n) {
 
             long r = n;
             long e = 0;
-            
+
             for (;;) {
                 while (e != r) {
                     if (o.isUnsubscribed()) {
                         return;
                     }
-                    
+
                     T value;
-                    
+
                     try {
                         value = it.next();
                     } catch (Throwable ex) {
                         Exceptions.throwOrReport(ex, o);
                         return;
                     }
-                    
+
                     o.onNext(value);
 
                     if (o.isUnsubscribed()) {
@@ -121,24 +121,24 @@ void slowpath(long n) {
                     }
 
                     boolean b;
-                    
+
                     try {
                         b = it.hasNext();
                     } catch (Throwable ex) {
                         Exceptions.throwOrReport(ex, o);
                         return;
                     }
-                    
+
                     if (!b) {
                         if (!o.isUnsubscribed()) {
                             o.onCompleted();
                         }
                         return;
                     }
-                    
+
                     e++;
                 }
-                
+
                 r = get();
                 if (e == r) {
                     r = BackpressureUtils.produced(this, e);
@@ -148,7 +148,7 @@ void slowpath(long n) {
                     e = 0L;
                 }
             }
-            
+
         }
 
         void fastpath() {
@@ -160,7 +160,7 @@ void fastpath() {
                 if (o.isUnsubscribed()) {
                     return;
                 }
-                
+
                 T value;
 
                 try {
@@ -169,7 +169,7 @@ void fastpath() {
                     Exceptions.throwOrReport(ex, o);
                     return;
                 }
-                
+
                 o.onNext(value);
 
                 if (o.isUnsubscribed()) {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java b/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
index ddab514cc9..4666751842 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -29,7 +29,7 @@
 
 /**
  * Correlates two sequences when they overlap and groups the results.
- * 
+ *
  * @see <a href="http://msdn.microsoft.com/en-us/library/hh244235.aspx">MSDN: Observable.GroupJoin</a>
  * @param <T1> the left value type
  * @param <T2> the right value type
@@ -67,9 +67,9 @@ public void call(Subscriber<? super R> child) {
     /** Manages sub-observers and subscriptions. */
     final class ResultManager extends HashMap<Integer, Observer<T2>>implements Subscription {
         // HashMap aspect of `this` refers to `leftMap`
-        
+
         private static final long serialVersionUID = -3035156013812425335L;
-        
+
         final RefCountSubscription cancel;
         final Subscriber<? super R> subscriber;
         final CompositeSubscription group;
@@ -78,7 +78,7 @@ final class ResultManager extends HashMap<Integer, Observer<T2>>implements Subsc
         /** Guarded by this. */
         int rightIds;
         /** Guarded by this. */
-        final Map<Integer, T2> rightMap = new HashMap<Integer, T2>(); // NOPMD 
+        final Map<Integer, T2> rightMap = new HashMap<Integer, T2>(); // NOPMD
         /** Guarded by this. */
         boolean leftDone;
         /** Guarded by this. */
@@ -95,7 +95,7 @@ public void init() {
 
             Subscriber<T1> s1 = new LeftObserver();
             Subscriber<T2> s2 = new RightObserver();
-            
+
             group.add(s1);
             group.add(s2);
 
@@ -107,16 +107,16 @@ public void init() {
         public void unsubscribe() {
             cancel.unsubscribe();
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return cancel.isUnsubscribed();
         }
-        
+
         Map<Integer, Observer<T2>> leftMap() {
             return this;
         }
-        
+
         /**
          * Notify everyone and cleanup.
          * @param e the exception
@@ -142,7 +142,7 @@ void errorMain(Throwable e) {
             synchronized (ResultManager.this) {
                 leftMap().clear();
                 rightMap.clear();
-            }            
+            }
             subscriber.onError(e);
             cancel.unsubscribe();
         }
@@ -155,7 +155,7 @@ void complete(List<Observer<T2>> list) {
                 cancel.unsubscribe();
             }
         }
-        
+
         /** Observe the left source. */
         final class LeftObserver extends Subscriber<T1> {
             @Override
@@ -164,7 +164,7 @@ public void onNext(T1 args) {
                     int id;
                     Subject<T2, T2> subj = PublishSubject.create();
                     Observer<T2> subjSerial = new SerializedObserver<T2>(subj);
-                    
+
                     synchronized (ResultManager.this) {
                         id = leftIds++;
                         leftMap().put(id, subjSerial);
@@ -184,13 +184,13 @@ public void onNext(T1 args) {
                     synchronized (ResultManager.this) {
                         rightMapValues = new ArrayList<T2>(rightMap.values());
                     }
-                    
+
                     subscriber.onNext(result);
                     for (T2 t2 : rightMapValues) {
                         subjSerial.onNext(t2);
                     }
-                    
-                    
+
+
                 } catch (Throwable t) {
                     Exceptions.throwOrReport(t, this);
                 }
@@ -230,7 +230,7 @@ public void onNext(T2 args) {
                     Observable<D2> duration = rightDuration.call(args);
 
                     Subscriber<D2> d2 = new RightDurationObserver(id);
-                    
+
                     group.add(d2);
                     duration.unsafeSubscribe(d2);
 
@@ -352,7 +352,7 @@ public void call(Subscriber<? super T> t1) {
             Subscription ref = refCount.get();
             WindowSubscriber wo = new WindowSubscriber(t1, ref);
             wo.add(ref);
-            
+
             underlying.unsafeSubscribe(wo);
         }
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeJoin.java b/src/main/java/rx/internal/operators/OnSubscribeJoin.java
index d5d7f08f3b..602263dc45 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeJoin.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeJoin.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -27,7 +27,7 @@
 
 /**
  * Correlates the elements of two sequences based on overlapping durations.
- * 
+ *
  * @param <TLeft> the left value type
  * @param <TRight> the right value type
  * @param <TLeftDuration> the left duration value type
@@ -63,7 +63,7 @@ public void call(Subscriber<? super R> t1) {
     /** Manage the left and right sources. */
     final class ResultSink extends HashMap<Integer,TLeft> {
         //HashMap aspect of `this` refers to the `leftMap`
-        
+
         private static final long serialVersionUID = 3491669543549085380L;
 
         final CompositeSubscription group;
@@ -90,13 +90,13 @@ public ResultSink(Subscriber<? super R> subscriber) {
         HashMap<Integer, TLeft> leftMap() {
             return this;
         }
-        
+
         public void run() {
             subscriber.add(group);
-            
+
             Subscriber<TLeft> s1 = new LeftSubscriber();
             Subscriber<TRight> s2 = new RightSubscriber();
-            
+
             group.add(s1);
             group.add(s2);
 
@@ -232,7 +232,7 @@ void expire(int id, Subscription resource) {
 
             @Override
             public void onNext(TRight args) {
-                int id; 
+                int id;
                 int highLeftId;
                 synchronized (ResultSink.this) {
                     id = rightId++;
@@ -248,9 +248,9 @@ public void onNext(TRight args) {
 
                     Subscriber<TRightDuration> d2 = new RightDurationSubscriber(id);
                     group.add(d2);
-                    
+
                     duration.unsafeSubscribe(d2);
-                    
+
 
                     List<TLeft> leftValues = new ArrayList<TLeft>();
                     synchronized (ResultSink.this) {
@@ -260,12 +260,12 @@ public void onNext(TRight args) {
                             }
                         }
                     }
-                    
+
                     for (TLeft lv : leftValues) {
                         R result = resultSelector.call(lv, args);
                         subscriber.onNext(result);
                     }
-                    
+
                 } catch (Throwable t) {
                     Exceptions.throwOrReport(t, this);
                 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeLift.java b/src/main/java/rx/internal/operators/OnSubscribeLift.java
index fd987d5800..a2c67f084e 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeLift.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeLift.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -28,7 +28,7 @@
  * @param <R> the result value type
  */
 public final class OnSubscribeLift<T, R> implements OnSubscribe<R> {
-    
+
     final OnSubscribe<T> parent;
 
     final Operator<? extends R, ? super T> operator;
@@ -47,7 +47,7 @@ public void call(Subscriber<? super R> o) {
                 st.onStart();
                 parent.call(st);
             } catch (Throwable e) {
-                // localized capture of errors rather than it skipping all operators 
+                // localized capture of errors rather than it skipping all operators
                 // and ending up in the try/catch of the subscribe method which then
                 // prevents onErrorResumeNext and other similar approaches to error handling
                 Exceptions.throwIfFatal(e);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeMap.java b/src/main/java/rx/internal/operators/OnSubscribeMap.java
index 0dc74df445..009d736e45 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeMap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeMap.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -26,45 +26,45 @@
  * this transformation as a new {@code Observable}.
  * <p>
  * <img width="640" height="305" src="https://raw.githubusercontent.com/wiki/ReactiveX/RxJava/images/rx-operators/map.png" alt="">
- * 
+ *
  * @param <T> the input value type
  * @param <R> the return value type
  */
 public final class OnSubscribeMap<T, R> implements OnSubscribe<R> {
 
     final Observable<T> source;
-    
+
     final Func1<? super T, ? extends R> transformer;
 
     public OnSubscribeMap(Observable<T> source, Func1<? super T, ? extends R> transformer) {
         this.source = source;
         this.transformer = transformer;
     }
-    
+
     @Override
     public void call(final Subscriber<? super R> o) {
         MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
         o.add(parent);
         source.unsafeSubscribe(parent);
     }
-    
+
     static final class MapSubscriber<T, R> extends Subscriber<T> {
-        
+
         final Subscriber<? super R> actual;
-        
+
         final Func1<? super T, ? extends R> mapper;
 
         boolean done;
-        
+
         public MapSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
             this.actual = actual;
             this.mapper = mapper;
         }
-        
+
         @Override
         public void onNext(T t) {
             R result;
-            
+
             try {
                 result = mapper.call(t);
             } catch (Throwable ex) {
@@ -73,10 +73,10 @@ public void onNext(T t) {
                 onError(OnErrorThrowable.addValueAsLastCause(ex, t));
                 return;
             }
-            
+
             actual.onNext(result);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             if (done) {
@@ -84,11 +84,11 @@ public void onError(Throwable e) {
                 return;
             }
             done = true;
-            
+
             actual.onError(e);
         }
-        
-        
+
+
         @Override
         public void onCompleted() {
             if (done) {
@@ -96,7 +96,7 @@ public void onCompleted() {
             }
             actual.onCompleted();
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             actual.setProducer(p);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
index f26dda29dc..d3a859b7c3 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -29,7 +29,7 @@
 public final class OnSubscribeOnAssembly<T> implements OnSubscribe<T> {
 
     final OnSubscribe<T> source;
-    
+
     final String stacktrace;
 
     /**
@@ -37,17 +37,17 @@ public final class OnSubscribeOnAssembly<T> implements OnSubscribe<T> {
      * stacktrace instead of the sanitized version.
      */
     public static volatile boolean fullStackTrace;
-    
+
     public OnSubscribeOnAssembly(OnSubscribe<T> source) {
         this.source = source;
         this.stacktrace = createStacktrace();
     }
-    
+
     static String createStacktrace() {
         StackTraceElement[] stes = Thread.currentThread().getStackTrace();
 
         StringBuilder sb = new StringBuilder("Assembly trace:");
-        
+
         for (StackTraceElement e : stes) {
             String row = e.toString();
             if (!fullStackTrace) {
@@ -87,7 +87,7 @@ static String createStacktrace() {
             }
             sb.append("\n at ").append(row);
         }
-        
+
         return sb.append("\nOriginal exception:").toString();
     }
 
@@ -95,13 +95,13 @@ static String createStacktrace() {
     public void call(Subscriber<? super T> t) {
         source.call(new OnAssemblySubscriber<T>(t, stacktrace));
     }
-    
+
     static final class OnAssemblySubscriber<T> extends Subscriber<T> {
 
         final Subscriber<? super T> actual;
-        
+
         final String stacktrace;
-        
+
         public OnAssemblySubscriber(Subscriber<? super T> actual, String stacktrace) {
             super(actual);
             this.actual = actual;
@@ -123,6 +123,6 @@ public void onError(Throwable e) {
         public void onNext(T t) {
             actual.onNext(t);
         }
-        
+
     }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
index c562013d88..8d78b6dbde 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -29,7 +29,7 @@
 public final class OnSubscribeOnAssemblyCompletable<T> implements Completable.OnSubscribe {
 
     final Completable.OnSubscribe source;
-    
+
     final String stacktrace;
 
     /**
@@ -37,23 +37,23 @@ public final class OnSubscribeOnAssemblyCompletable<T> implements Completable.On
      * stacktrace instead of the sanitized version.
      */
     public static volatile boolean fullStackTrace;
-    
+
     public OnSubscribeOnAssemblyCompletable(Completable.OnSubscribe source) {
         this.source = source;
         this.stacktrace = OnSubscribeOnAssembly.createStacktrace();
     }
-    
+
     @Override
     public void call(CompletableSubscriber t) {
         source.call(new OnAssemblyCompletableSubscriber(t, stacktrace));
     }
-    
+
     static final class OnAssemblyCompletableSubscriber implements CompletableSubscriber {
 
         final CompletableSubscriber actual;
-        
+
         final String stacktrace;
-        
+
         public OnAssemblyCompletableSubscriber(CompletableSubscriber actual, String stacktrace) {
             this.actual = actual;
             this.stacktrace = stacktrace;
@@ -63,7 +63,7 @@ public OnAssemblyCompletableSubscriber(CompletableSubscriber actual, String stac
         public void onSubscribe(Subscription d) {
             actual.onSubscribe(d);
         }
-        
+
         @Override
         public void onCompleted() {
             actual.onCompleted();
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java
index be5ce6cb5f..5c38b02ad4 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblySingle.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -28,7 +28,7 @@
 public final class OnSubscribeOnAssemblySingle<T> implements Single.OnSubscribe<T> {
 
     final Single.OnSubscribe<T> source;
-    
+
     final String stacktrace;
 
     /**
@@ -36,23 +36,23 @@ public final class OnSubscribeOnAssemblySingle<T> implements Single.OnSubscribe<
      * stacktrace instead of the sanitized version.
      */
     public static volatile boolean fullStackTrace;
-    
+
     public OnSubscribeOnAssemblySingle(Single.OnSubscribe<T> source) {
         this.source = source;
         this.stacktrace = OnSubscribeOnAssembly.createStacktrace();
     }
-    
+
     @Override
     public void call(SingleSubscriber<? super T> t) {
         source.call(new OnAssemblySingleSubscriber<T>(t, stacktrace));
     }
-    
+
     static final class OnAssemblySingleSubscriber<T> extends SingleSubscriber<T> {
 
         final SingleSubscriber<? super T> actual;
-        
+
         final String stacktrace;
-        
+
         public OnAssemblySingleSubscriber(SingleSubscriber<? super T> actual, String stacktrace) {
             this.actual = actual;
             this.stacktrace = stacktrace;
@@ -69,6 +69,6 @@ public void onError(Throwable e) {
         public void onSuccess(T t) {
             actual.onSuccess(t);
         }
-        
+
     }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribePublishMulticast.java b/src/main/java/rx/internal/operators/OnSubscribePublishMulticast.java
index c1d14b29fa..d48b857594 100644
--- a/src/main/java/rx/internal/operators/OnSubscribePublishMulticast.java
+++ b/src/main/java/rx/internal/operators/OnSubscribePublishMulticast.java
@@ -27,23 +27,23 @@
 /**
  * Multicasts notifications coming through its input Subscriber view to its
  * client Subscribers via lockstep backpressure mode.
- * 
+ *
  * <p>The difference between this class and OperatorPublish is that this
  * class doesn't consume the upstream if there are no child subscribers but
  * waits for them to show up. Plus if the upstream source terminates, late
  * subscribers will be immediately terminated with the same terminal event
  * unlike OperatorPublish which just waits for the next connection.
- * 
+ *
  * <p>The class extends AtomicInteger which is the work-in-progress gate
  * for the drain-loop serializing subscriptions and child request changes.
- * 
+ *
  * @param <T> the input and output type
  */
-public final class OnSubscribePublishMulticast<T> extends AtomicInteger 
+public final class OnSubscribePublishMulticast<T> extends AtomicInteger
 implements Observable.OnSubscribe<T>, Observer<T>, Subscription {
     /** */
     private static final long serialVersionUID = -3741892510772238743L;
-    /** 
+    /**
      * The prefetch queue holding onto a fixed amount of items until all
      * all child subscribers have requested something.
      */
@@ -52,7 +52,7 @@ public final class OnSubscribePublishMulticast<T> extends AtomicInteger
      * The number of items to prefetch from the upstreams source.
      */
     final int prefetch;
-    
+
     /**
      * Delays the error delivery to happen only after all values have been consumed.
      */
@@ -63,10 +63,10 @@ public final class OnSubscribePublishMulticast<T> extends AtomicInteger
     final ParentSubscriber<T> parent;
     /** Indicates the upstream has completed. */
     volatile boolean done;
-    /** 
+    /**
      * Holds onto the upstream's exception if done is true and this field is non-null.
      * <p>This field must be read after done or if subscribers == TERMINATED to
-     * establish a proper happens-before. 
+     * establish a proper happens-before.
      */
     Throwable error;
 
@@ -78,10 +78,10 @@ public final class OnSubscribePublishMulticast<T> extends AtomicInteger
      * A copy-on-write array of currently subscribed child subscribers' wrapper structure.
      */
     volatile PublishProducer<T>[] subscribers;
-    
-    /** 
-     * Represents an empty array of subscriber wrapper, 
-     * helps avoid allocating an empty array all the time. 
+
+    /**
+     * Represents an empty array of subscriber wrapper,
+     * helps avoid allocating an empty array all the time.
      */
     static final PublishProducer<?>[] EMPTY = new PublishProducer[0];
 
@@ -112,13 +112,13 @@ public OnSubscribePublishMulticast(int prefetch, boolean delayError) {
         this.subscribers = (PublishProducer<T>[]) EMPTY;
         this.parent = new ParentSubscriber<T>(this);
     }
-    
+
     @Override
     public void call(Subscriber<? super T> t) {
         PublishProducer<T> pp = new PublishProducer<T>(t, this);
         t.add(pp);
         t.setProducer(pp);
-        
+
         if (add(pp)) {
             if (pp.isUnsubscribed()) {
                 remove(pp);
@@ -134,31 +134,31 @@ public void call(Subscriber<? super T> t) {
             }
         }
     }
-    
+
     @Override
     public void onNext(T t) {
         if (!queue.offer(t)) {
             parent.unsubscribe();
-            
+
             error = new MissingBackpressureException("Queue full?!");
             done = true;
         }
         drain();
     }
-    
+
     @Override
     public void onError(Throwable e) {
         error = e;
         done = true;
         drain();
     }
-    
+
     @Override
     public void onCompleted() {
         done = true;
         drain();
     }
-    
+
     /**
      * Sets the main producer and issues the prefetch amount.
      * @param p the producer to set
@@ -167,64 +167,64 @@ void setProducer(Producer p) {
         this.producer = p;
         p.request(prefetch);
     }
-    
+
     /**
      * The serialization loop that determines the minimum request of
      * all subscribers and tries to emit as many items from the queue if
      * they are available.
-     * 
+     *
      * <p>The execution of the drain-loop is guaranteed to be thread-safe.
      */
     void drain() {
         if (getAndIncrement() != 0) {
             return;
         }
-        
+
         final Queue<T> q = queue;
-        
+
         int missed = 0;
-        
+
         for (;;) {
-            
+
             long r = Long.MAX_VALUE;
             PublishProducer<T>[] a = subscribers;
             int n = a.length;
-            
+
             for (PublishProducer<T> inner : a) {
                 r = Math.min(r, inner.get());
             }
-            
+
             if (n != 0) {
                 long e = 0L;
-                
+
                 while (e != r) {
                     boolean d = done;
-                    
+
                     T v = q.poll();
-                    
+
                     boolean empty = v == null;
-                    
+
                     if (checkTerminated(d, empty)) {
                         return;
                     }
-                    
+
                     if (empty) {
                         break;
                     }
-                    
+
                     for (PublishProducer<T> inner : a) {
                         inner.actual.onNext(v);
                     }
-                    
+
                     e++;
                 }
-                
+
                 if (e == r) {
                     if (checkTerminated(done, q.isEmpty())) {
                         return;
                     }
                 }
-                
+
                 if (e != 0L) {
                     Producer p = producer;
                     if (p != null) {
@@ -233,17 +233,17 @@ void drain() {
                     for (PublishProducer<T> inner : a) {
                         BackpressureUtils.produced(inner, e);
                     }
-                    
+
                 }
             }
-            
+
             missed = addAndGet(-missed);
             if (missed == 0) {
                 break;
             }
         }
     }
-    
+
     /**
      * Given the current source state, terminates all child subscribers.
      * @param d the source-done indicator
@@ -306,7 +306,7 @@ PublishProducer<T>[] terminate() {
         }
         return a;
     }
-    
+
     /**
      * Atomically adds the given wrapper of a child Subscriber to the subscribers array.
      * @param inner the wrapper
@@ -322,7 +322,7 @@ boolean add(PublishProducer<T> inner) {
             if (a == TERMINATED) {
                 return false;
             }
-            
+
             int n = a.length;
             @SuppressWarnings("unchecked")
             PublishProducer<T>[] b = new PublishProducer[n + 1];
@@ -348,21 +348,21 @@ void remove(PublishProducer<T> inner) {
             if (a == TERMINATED || a == EMPTY) {
                 return;
             }
-            
+
             int j = -1;
             int n = a.length;
-            
+
             for (int i = 0; i < n; i++) {
                 if (a[i] == inner) {
                     j = i;
                     break;
                 }
             }
-            
+
             if (j < 0) {
                 return;
             }
-            
+
             PublishProducer<T>[] b;
             if (n == 1) {
                 b = (PublishProducer<T>[])EMPTY;
@@ -382,33 +382,33 @@ void remove(PublishProducer<T> inner) {
     static final class ParentSubscriber<T> extends Subscriber<T> {
         /** The reference to the parent state where the events are forwarded to. */
         final OnSubscribePublishMulticast<T> state;
-        
+
         public ParentSubscriber(OnSubscribePublishMulticast<T> state) {
             super();
             this.state = state;
         }
-        
+
         @Override
         public void onNext(T t) {
             state.onNext(t);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             state.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             state.onCompleted();
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             state.setProducer(p);
         }
     }
-    
+
     /**
      * Returns the input subscriber of this class that must be subscribed
      * to the upstream source.
@@ -417,27 +417,27 @@ public void setProducer(Producer p) {
     public Subscriber<T> subscriber() {
         return parent;
     }
-    
+
     @Override
     public void unsubscribe() {
         parent.unsubscribe();
     }
-    
+
     @Override
     public boolean isUnsubscribed() {
         return parent.isUnsubscribed();
     }
-    
+
     /**
      * A Producer and Subscription that wraps a child Subscriber and manages
      * its backpressure requests along with its unsubscription from the parent
      * class.
-     * 
+     *
      * <p>The class extends AtomicLong that holds onto the child's requested amount.
-     * 
+     *
      * @param <T> the output value type
      */
-    static final class PublishProducer<T> 
+    static final class PublishProducer<T>
     extends AtomicLong
     implements Producer, Subscription {
         /** */
@@ -445,10 +445,10 @@ static final class PublishProducer<T>
 
         /** The actual subscriber to receive the events. */
         final Subscriber<? super T> actual;
-        
+
         /** The parent object to request draining or removal. */
         final OnSubscribePublishMulticast<T> parent;
-        
+
         /** Makes sure unsubscription happens only once. */
         final AtomicBoolean once;
 
@@ -457,7 +457,7 @@ public PublishProducer(Subscriber<? super T> actual, OnSubscribePublishMulticast
             this.parent = parent;
             this.once = new AtomicBoolean();
         }
-        
+
         @Override
         public void request(long n) {
             if (n < 0) {
@@ -468,12 +468,12 @@ public void request(long n) {
                 parent.drain();
             }
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return once.get();
         }
-        
+
         @Override
         public void unsubscribe() {
             if (once.compareAndSet(false, true)) {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeRange.java b/src/main/java/rx/internal/operators/OnSubscribeRange.java
index 1a96c152c8..4268917ef3 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRange.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRange.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -41,7 +41,7 @@ public void call(final Subscriber<? super Integer> childSubscriber) {
     static final class RangeProducer extends AtomicLong implements Producer {
         /** */
         private static final long serialVersionUID = 4114392207069098388L;
-        
+
         private final Subscriber<? super Integer> childSubscriber;
         private final int endOfRange;
         private long currentIndex;
@@ -77,33 +77,33 @@ void slowpath(long requestedAmount) {
             long emitted = 0L;
             long endIndex = endOfRange + 1L;
             long index = currentIndex;
-            
+
             final Subscriber<? super Integer> childSubscriber = this.childSubscriber;
-            
+
             for (;;) {
-                
+
                 while (emitted != requestedAmount && index != endIndex) {
                     if (childSubscriber.isUnsubscribed()) {
                         return;
                     }
-                    
+
                     childSubscriber.onNext((int)index);
-                    
+
                     index++;
                     emitted++;
                 }
-                
+
                 if (childSubscriber.isUnsubscribed()) {
                     return;
                 }
-                
+
                 if (index == endIndex) {
                     childSubscriber.onCompleted();
                     return;
                 }
-                
+
                 requestedAmount = get();
-                
+
                 if (requestedAmount == emitted) {
                     currentIndex = index;
                     requestedAmount = addAndGet(-emitted);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeRedo.java b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
index 06830122ff..628c58f4ef 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRedo.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -17,13 +17,13 @@
 
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -75,13 +75,13 @@ public Observable<?> call(Observable<? extends Notification<?>> ts) {
             return ts.map(new Func1<Notification<?>, Notification<?>>() {
 
                 int num;
-                
+
                 @Override
                 public Notification<?> call(Notification<?> terminalNotification) {
                     if(count == 0) {
                         return terminalNotification;
                     }
-                    
+
                     num++;
                     if(num <= count) {
                         return Notification.createOnNext(num);
@@ -89,7 +89,7 @@ public Notification<?> call(Notification<?> terminalNotification) {
                         return terminalNotification;
                     }
                 }
-                
+
             }).dematerialize();
         }
     }
@@ -185,10 +185,10 @@ private OnSubscribeRedo(Observable<T> source, Func1<? super Observable<? extends
 
     @Override
     public void call(final Subscriber<? super T> child) {
-        
+
         // when true is a marker to say we are ready to resubscribe to source
         final AtomicBoolean resumeBoundary = new AtomicBoolean(true);
-        
+
         // incremented when requests are made, decremented when requests are fulfilled
         final AtomicLong consumerCapacity = new AtomicLong();
 
@@ -198,18 +198,18 @@ public void call(final Subscriber<? super T> child) {
         final SerialSubscription sourceSubscriptions = new SerialSubscription();
         child.add(sourceSubscriptions);
 
-        // use a subject to receive terminals (onCompleted and onError signals) from 
-        // the source observable. We use a BehaviorSubject because subscribeToSource 
-        // may emit a terminal before the restarts observable (transformed terminals) 
+        // use a subject to receive terminals (onCompleted and onError signals) from
+        // the source observable. We use a BehaviorSubject because subscribeToSource
+        // may emit a terminal before the restarts observable (transformed terminals)
         // is subscribed
         final Subject<Notification<?>, Notification<?>> terminals = BehaviorSubject.<Notification<?>>create().toSerialized();
         final Subscriber<Notification<?>> dummySubscriber = Subscribers.empty();
-        // subscribe immediately so the last emission will be replayed to the next 
+        // subscribe immediately so the last emission will be replayed to the next
         // subscriber (which is the one we care about)
         terminals.subscribe(dummySubscriber);
 
         final ProducerArbiter arbiter = new ProducerArbiter();
-        
+
         final Action0 subscribeToSource = new Action0() {
             @Override
             public void call() {
@@ -274,8 +274,8 @@ public void setProducer(Producer producer) {
             }
         };
 
-        // the observable received by the control handler function will receive notifications of onCompleted in the case of 'repeat' 
-        // type operators or notifications of onError for 'retry' this is done by lifting in a custom operator to selectively divert 
+        // the observable received by the control handler function will receive notifications of onCompleted in the case of 'repeat'
+        // type operators or notifications of onError for 'retry' this is done by lifting in a custom operator to selectively divert
         // the retry/repeat relevant values to the control handler
         final Observable<?> restarts = controlHandlerFunction.call(
                 terminals.lift(new Operator<Notification<?>, Notification<?>>() {
@@ -329,8 +329,8 @@ public void onError(Throwable e) {
                     @Override
                     public void onNext(Object t) {
                         if (!child.isUnsubscribed()) {
-                            // perform a best endeavours check on consumerCapacity 
-                            // with the intent of only resubscribing immediately 
+                            // perform a best endeavours check on consumerCapacity
+                            // with the intent of only resubscribing immediately
                             // if there is outstanding capacity
                             if (consumerCapacity.get() > 0) {
                                 worker.schedule(subscribeToSource);
@@ -363,6 +363,6 @@ public void request(final long n) {
                 }
             }
         });
-        
+
     }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeReduce.java b/src/main/java/rx/internal/operators/OnSubscribeReduce.java
index 5136aa376e..d07daebcd4 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeReduce.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeReduce.java
@@ -27,14 +27,14 @@
 public final class OnSubscribeReduce<T> implements OnSubscribe<T> {
 
     final Observable<T> source;
-    
+
     final Func2<T, T, T> reducer;
 
     public OnSubscribeReduce(Observable<T> source, Func2<T, T, T> reducer) {
         this.source = source;
         this.reducer = reducer;
     }
-    
+
     @Override
     public void call(Subscriber<? super T> t) {
         final ReduceSubscriber<T> parent = new ReduceSubscriber<T>(t, reducer);
@@ -47,19 +47,19 @@ public void request(long n) {
         });
         source.unsafeSubscribe(parent);
     }
-    
+
     static final class ReduceSubscriber<T> extends Subscriber<T> {
 
         final Subscriber<? super T> actual;
-        
+
         final Func2<T, T, T> reducer;
 
         T value;
-        
+
         static final Object EMPTY = new Object();
-        
+
         boolean done;
-        
+
         @SuppressWarnings("unchecked")
         public ReduceSubscriber(Subscriber<? super T> actual, Func2<T, T, T> reducer) {
             this.actual = actual;
@@ -87,7 +87,7 @@ public void onNext(T t) {
                 }
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             if (!done) {
@@ -97,7 +97,7 @@ public void onError(Throwable e) {
                 RxJavaHooks.onError(e);
             }
         }
-        
+
         @SuppressWarnings("unchecked")
         @Override
         public void onCompleted() {
@@ -113,7 +113,7 @@ public void onCompleted() {
                 actual.onError(new NoSuchElementException());
             }
         }
-        
+
         void downstreamRequest(long n) {
             if (n < 0L) {
                 throw new IllegalArgumentException("n >= 0 required but it was " + n);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeReduceSeed.java b/src/main/java/rx/internal/operators/OnSubscribeReduceSeed.java
index 12c023238a..90d978ffe4 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeReduceSeed.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeReduceSeed.java
@@ -24,9 +24,9 @@
 public final class OnSubscribeReduceSeed<T, R> implements OnSubscribe<R> {
 
     final Observable<T> source;
-    
+
     final R initialValue;
-    
+
     final Func2<R, ? super T, R> reducer;
 
     public OnSubscribeReduceSeed(Observable<T> source, R initialValue, Func2<R, ? super T, R> reducer) {
@@ -34,12 +34,12 @@ public OnSubscribeReduceSeed(Observable<T> source, R initialValue, Func2<R, ? su
         this.initialValue = initialValue;
         this.reducer = reducer;
     }
-    
+
     @Override
     public void call(Subscriber<? super R> t) {
         new ReduceSeedSubscriber<T, R>(t, initialValue, reducer).subscribeTo(source);
     }
-    
+
     static final class ReduceSeedSubscriber<T, R> extends DeferredScalarSubscriber<T, R> {
 
         final Func2<R, ? super T, R> reducer;
@@ -61,6 +61,6 @@ public void onNext(T t) {
                 actual.onError(ex);
             }
         }
-        
+
     }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeRefCount.java b/src/main/java/rx/internal/operators/OnSubscribeRefCount.java
index 7bcc9872c8..c5898ac1b6 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRefCount.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRefCount.java
@@ -27,7 +27,7 @@
 /**
  * Returns an observable sequence that stays connected to the source as long as
  * there is at least one subscription to the observable sequence.
- * 
+ *
  * @param <T>
  *            the value type
  */
@@ -44,7 +44,7 @@ public final class OnSubscribeRefCount<T> implements OnSubscribe<T> {
 
     /**
      * Constructor.
-     * 
+     *
      * @param source
      *            observable to apply ref count to
      */
@@ -104,11 +104,11 @@ public void call(Subscription subscription) {
             }
         };
     }
-    
+
     void doSubscribe(final Subscriber<? super T> subscriber, final CompositeSubscription currentBase) {
         // handle unsubscribing from the base subscription
         subscriber.add(disconnect(currentBase));
-        
+
         source.unsafeSubscribe(new Subscriber<T>(subscriber) {
             @Override
             public void onError(Throwable e) {
@@ -126,7 +126,7 @@ public void onCompleted() {
             }
             void cleanup() {
                 // on error or completion we need to unsubscribe the base subscription
-                // and set the subscriptionCount to 0 
+                // and set the subscriptionCount to 0
                 lock.lock();
                 try {
                     if (baseSubscription == currentBase) {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeSkipTimed.java b/src/main/java/rx/internal/operators/OnSubscribeSkipTimed.java
index b9f47d2c7a..d5dc901eed 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeSkipTimed.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeSkipTimed.java
@@ -50,7 +50,7 @@ public void call(final Subscriber<? super T> child) {
         worker.schedule(subscriber, time, unit);
         source.unsafeSubscribe(subscriber);
     }
-    
+
     final static class SkipTimedSubscriber<T> extends Subscriber<T> implements Action0 {
 
         final Subscriber<? super T> child;
@@ -64,7 +64,7 @@ final static class SkipTimedSubscriber<T> extends Subscriber<T> implements Actio
         public void call() {
             gate = true;
         }
-        
+
         @Override
         public void onNext(T t) {
             if (gate) {
@@ -89,6 +89,6 @@ public void onCompleted() {
                 unsubscribe();
             }
         }
-        
+
     }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeTakeLastOne.java b/src/main/java/rx/internal/operators/OnSubscribeTakeLastOne.java
index a07873d161..7ad0959588 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeTakeLastOne.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeTakeLastOne.java
@@ -26,16 +26,16 @@ public final class OnSubscribeTakeLastOne<T> implements OnSubscribe<T> {
     public OnSubscribeTakeLastOne(Observable<T> source) {
         this.source = source;
     }
-    
+
     @Override
     public void call(Subscriber<? super T> t) {
         new TakeLastOneSubscriber<T>(t).subscribeTo(source);
     }
-    
+
     static final class TakeLastOneSubscriber<T> extends DeferredScalarSubscriber<T, T> {
 
         static final Object EMPTY = new Object();
-        
+
         @SuppressWarnings("unchecked")
         public TakeLastOneSubscriber(Subscriber<? super T> actual) {
             super(actual);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeThrow.java b/src/main/java/rx/internal/operators/OnSubscribeThrow.java
index d39bba5939..381d5dd1cc 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeThrow.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeThrow.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -21,7 +21,7 @@
 
 /**
  * An Observable that invokes {@link Observer#onError onError} when the {@link Observer} subscribes to it.
- * 
+ *
  * @param <T>
  *            the type of item (ostensibly) emitted by the Observable
  */
@@ -35,7 +35,7 @@ public OnSubscribeThrow(Throwable exception) {
 
     /**
      * Accepts an {@link Observer} and calls its {@link Observer#onError onError} method.
-     * 
+     *
      * @param observer
      *            an {@link Observer} of this Observable
      */
diff --git a/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java b/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java
index 8cd0c77618..b6acfa1b6f 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeTimerOnce.java
@@ -55,5 +55,5 @@ public void call() {
             }
         }, time, unit);
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java b/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java
index 0782f5130c..d718a6906b 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeTimerPeriodically.java
@@ -58,7 +58,7 @@ public void call() {
                     }
                 }
             }
-            
+
         }, initialDelay, period, unit);
     }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeToMap.java b/src/main/java/rx/internal/operators/OnSubscribeToMap.java
index 6b254c172e..ca35c8e951 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeToMap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeToMap.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -29,7 +29,7 @@
 /**
  * Maps the elements of the source observable into a java.util.Map instance and
  * emits that once the source observable completes.
- * 
+ *
  * @see <a href="https://github.com/ReactiveX/RxJava/issues/96">Issue #96</a>
  * @param <T> the value type of the input
  * @param <K> the map-key type
@@ -83,7 +83,7 @@ public OnSubscribeToMap(Observable<T> source,
     public Map<K, V> call() {
         return new HashMap<K, V>();
     }
-    
+
     @Override
     public void call(final Subscriber<? super Map<K, V>> subscriber) {
         Map<K, V> map;
@@ -94,9 +94,9 @@ public void call(final Subscriber<? super Map<K, V>> subscriber) {
             return;
         }
         new ToMapSubscriber<T, K, V>(subscriber, map, keySelector, valueSelector)
-            .subscribeTo(source);;    
+            .subscribeTo(source);;
     }
-    
+
     static final class ToMapSubscriber<T, K, V> extends DeferredScalarSubscriberSafe<T, Map<K,V>> {
 
         final Func1<? super T, ? extends K> keySelector;
@@ -115,7 +115,7 @@ static final class ToMapSubscriber<T, K, V> extends DeferredScalarSubscriberSafe
         public void onStart() {
             request(Long.MAX_VALUE);
         }
-        
+
         @Override
         public void onNext(T t) {
             if (done) {
@@ -132,5 +132,5 @@ public void onNext(T t) {
             }
         }
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java b/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
index f8c8b42e05..6883e93d24 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
@@ -71,7 +71,7 @@ public OnSubscribeToMultimap(
      * @param mapFactory function that returns a Map instance to store keys and values into
      */
     public OnSubscribeToMultimap(
-            Observable<T> source, 
+            Observable<T> source,
             Func1<? super T, ? extends K> keySelector,
             Func1<? super T, ? extends V> valueSelector,
             Func0<? extends Map<K, Collection<V>>> mapFactory) {
@@ -90,7 +90,7 @@ public OnSubscribeToMultimap(
      * @param collectionFactory function that returns a Collection for a particular key to store values into
      */
     public OnSubscribeToMultimap(
-            Observable<T> source, 
+            Observable<T> source,
             Func1<? super T, ? extends K> keySelector,
             Func1<? super T, ? extends V> valueSelector,
             Func0<? extends Map<K, Collection<V>>> mapFactory,
@@ -111,10 +111,10 @@ public OnSubscribeToMultimap(
     public Map<K, Collection<V>> call() {
         return new HashMap<K, Collection<V>>();
     }
-    
+
     @Override
     public void call(final Subscriber<? super Map<K, Collection<V>>> subscriber) {
-        
+
         Map<K, Collection<V>> map;
         try {
             map = mapFactory.call();
@@ -127,8 +127,8 @@ public void call(final Subscriber<? super Map<K, Collection<V>>> subscriber) {
                 subscriber, map, keySelector, valueSelector, collectionFactory)
             .subscribeTo(source);
     }
-    
-    private static final class ToMultimapSubscriber<T, K, V> 
+
+    private static final class ToMultimapSubscriber<T, K, V>
         extends DeferredScalarSubscriberSafe<T,Map<K, Collection<V>>> {
 
         private final Func1<? super T, ? extends K> keySelector;
@@ -136,7 +136,7 @@ private static final class ToMultimapSubscriber<T, K, V>
         private final Func1<? super K, ? extends Collection<V>> collectionFactory;
 
         ToMultimapSubscriber(
-            Subscriber<? super Map<K, Collection<V>>> subscriber, 
+            Subscriber<? super Map<K, Collection<V>>> subscriber,
             Map<K, Collection<V>> map,
             Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector,
             Func1<? super K, ? extends Collection<V>> collectionFactory) {
@@ -147,7 +147,7 @@ private static final class ToMultimapSubscriber<T, K, V>
             this.valueSelector = valueSelector;
             this.collectionFactory = collectionFactory;
         }
-        
+
         @Override
         public void onStart() {
             request(Long.MAX_VALUE);
@@ -159,10 +159,10 @@ public void onNext(T t) {
                 return;
             }
             try {
-                // any interaction with keySelector, valueSelector, collectionFactory, collection or value 
-                // may fail unexpectedly because their behaviour is customisable by the user. For this 
+                // any interaction with keySelector, valueSelector, collectionFactory, collection or value
+                // may fail unexpectedly because their behaviour is customisable by the user. For this
                 // reason we wrap their calls in try-catch block.
-                
+
                 K key = keySelector.call(t);
                 V v = valueSelector.call(t);
                 Collection<V> collection = value.get(key);
@@ -179,7 +179,7 @@ public void onNext(T t) {
 
           }
     }
-        
+
     /**
      * The default collection factory for a key in the multimap returning
      * an ArrayList independent of the key.
@@ -188,18 +188,18 @@ public void onNext(T t) {
      */
     private static final class DefaultMultimapCollectionFactory<K, V>
             implements Func1<K, Collection<V>> {
-        
+
         private static final DefaultMultimapCollectionFactory<Object,Object> INSTANCE = new DefaultMultimapCollectionFactory<Object, Object>();
-        
+
         @SuppressWarnings("unchecked")
         static <K, V>  DefaultMultimapCollectionFactory<K,V> instance() {
             return (DefaultMultimapCollectionFactory<K, V>) INSTANCE;
         }
-        
+
         @Override
         public Collection<V> call(K t1) {
             return new ArrayList<V>();
         }
     }
-    
+
 }
\ No newline at end of file
diff --git a/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java b/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
index 8e469c296e..b86b331753 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeToObservableFuture.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/operators/OnSubscribeUsing.java b/src/main/java/rx/internal/operators/OnSubscribeUsing.java
index 5b5a9259fb..110a8393e7 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeUsing.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeUsing.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -25,7 +25,7 @@
 
 /**
  * Constructs an observable sequence that depends on a resource object.
- * 
+ *
  * @param <T> the output value type
  * @param <Resource> the resource type
  */
@@ -88,7 +88,7 @@ public void call(final Subscriber<? super T> subscriber) {
                 // dispose after the terminal signals were sent out
                         .doAfterTerminate(disposeOnceOnly);
             }
-            
+
             try {
                 // start
                 observable.unsafeSubscribe(Subscribers.wrap(subscriber));
diff --git a/src/main/java/rx/internal/operators/OperatorAll.java b/src/main/java/rx/internal/operators/OperatorAll.java
index c9ef535dbd..73c7a487e1 100644
--- a/src/main/java/rx/internal/operators/OperatorAll.java
+++ b/src/main/java/rx/internal/operators/OperatorAll.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -58,8 +58,8 @@ public void onNext(T t) {
                     done = true;
                     producer.setValue(false);
                     unsubscribe();
-                } 
-                // note that don't need to request more of upstream because this subscriber 
+                }
+                // note that don't need to request more of upstream because this subscriber
                 // defaults to requesting Long.MAX_VALUE
             }
 
diff --git a/src/main/java/rx/internal/operators/OperatorAny.java b/src/main/java/rx/internal/operators/OperatorAny.java
index 558bb005ac..5e2b73632b 100644
--- a/src/main/java/rx/internal/operators/OperatorAny.java
+++ b/src/main/java/rx/internal/operators/OperatorAny.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -61,8 +61,8 @@ public void onNext(T t) {
                     done = true;
                     producer.setValue(!returnOnEmpty);
                     unsubscribe();
-                } 
-                // note that don't need to request more of upstream because this subscriber 
+                }
+                // note that don't need to request more of upstream because this subscriber
                 // defaults to requesting Long.MAX_VALUE
             }
 
diff --git a/src/main/java/rx/internal/operators/OperatorAsObservable.java b/src/main/java/rx/internal/operators/OperatorAsObservable.java
index 33671e8f2e..26037450b7 100644
--- a/src/main/java/rx/internal/operators/OperatorAsObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorAsObservable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -20,7 +20,7 @@
 
 /**
  * Hides the identity of another observable.
- * 
+ *
  * @param <T>
  *            the return value type of the wrapped observable.
  */
@@ -38,13 +38,13 @@ static final class Holder {
     public static <T> OperatorAsObservable<T> instance() {
         return (OperatorAsObservable<T>)Holder.INSTANCE;
     }
-    OperatorAsObservable() { 
+    OperatorAsObservable() {
         // singleton
     }
-    
+
     @Override
     public Subscriber<? super T> call(Subscriber<? super T> s) {
         return s;
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java b/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
index 4c86c8b089..eb3f3c8f9f 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
@@ -37,7 +37,7 @@
  * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
  * exactly one buffer actively storing values.
  * </p>
- * 
+ *
  * @param <T> the buffered value type
  * @param <TClosing> the value type of the Observable signaling the end of each buffer
  */
@@ -104,12 +104,12 @@ public void onCompleted() {
 
         child.add(closingSubscriber);
         child.add(bsub);
-        
+
         closing.unsafeSubscribe(closingSubscriber);
-        
+
         return bsub;
     }
-    
+
     final class BufferingSubscriber extends Subscriber<T> {
         final Subscriber<? super List<T>> child;
         /** Guarded by this. */
@@ -163,7 +163,7 @@ public void onCompleted() {
             child.onCompleted();
             unsubscribe();
         }
-        
+
         void emit() {
             List<T> toEmit;
             synchronized (this) {
@@ -187,5 +187,5 @@ void emit() {
             }
         }
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithSize.java b/src/main/java/rx/internal/operators/OperatorBufferWithSize.java
index 6475547563..5b9877e842 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithSize.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithSize.java
@@ -44,7 +44,7 @@ public final class OperatorBufferWithSize<T> implements Operator<List<T>, T> {
      * @param count
      *            the number of elements a buffer should have before being emitted
      * @param skip
-     *            the interval with which chunks have to be created. Note that when {@code skip == count} 
+     *            the interval with which chunks have to be created. Note that when {@code skip == count}
      *            the operator will produce non-overlapping chunks. If
      *            {@code skip < count}, this buffer operation will produce overlapping chunks and if
      *            {@code skip > count} non-overlapping chunks will be created and some values will not be pushed
@@ -65,40 +65,40 @@ public OperatorBufferWithSize(int count, int skip) {
     public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
         if (skip == count) {
             BufferExact<T> parent = new BufferExact<T>(child, count);
-            
+
             child.add(parent);
             child.setProducer(parent.createProducer());
-            
+
             return parent;
         }
         if (skip > count) {
             BufferSkip<T> parent = new BufferSkip<T>(child, count, skip);
-            
+
             child.add(parent);
             child.setProducer(parent.createProducer());
-            
+
             return parent;
         }
         BufferOverlap<T> parent = new BufferOverlap<T>(child, count, skip);
-        
+
         child.add(parent);
         child.setProducer(parent.createProducer());
-        
+
         return parent;
     }
-    
+
     static final class BufferExact<T> extends Subscriber<T> {
         final Subscriber<? super List<T>> actual;
         final int count;
 
         List<T> buffer;
-        
+
         public BufferExact(Subscriber<? super List<T>> actual, int count) {
             this.actual = actual;
             this.count = count;
             this.request(0L);
         }
-        
+
         @Override
         public void onNext(T t) {
             List<T> b = buffer;
@@ -106,21 +106,21 @@ public void onNext(T t) {
                 b = new ArrayList<T>(count);
                 buffer = b;
             }
-            
+
             b.add(t);
-            
+
             if (b.size() == count) {
                 buffer = null;
                 actual.onNext(b);
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             buffer = null;
             actual.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             List<T> b = buffer;
@@ -129,7 +129,7 @@ public void onCompleted() {
             }
             actual.onCompleted();
         }
-        
+
         Producer createProducer() {
             return new Producer() {
                 @Override
@@ -145,14 +145,14 @@ public void request(long n) {
             };
         }
     }
-    
+
     static final class BufferSkip<T> extends Subscriber<T> {
         final Subscriber<? super List<T>> actual;
         final int count;
         final int skip;
-        
+
         long index;
-        
+
         List<T> buffer;
 
         public BufferSkip(Subscriber<? super List<T>> actual, int count, int skip) {
@@ -161,7 +161,7 @@ public BufferSkip(Subscriber<? super List<T>> actual, int count, int skip) {
             this.skip = skip;
             this.request(0L);
         }
-        
+
         @Override
         public void onNext(T t) {
             long i = index;
@@ -176,23 +176,23 @@ public void onNext(T t) {
             } else {
                 index = i;
             }
-            
+
             if (b != null) {
                 b.add(t);
-                
+
                 if (b.size() == count) {
                     buffer = null;
                     actual.onNext(b);
                 }
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             buffer = null;
             actual.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             List<T> b = buffer;
@@ -202,11 +202,11 @@ public void onCompleted() {
             }
             actual.onCompleted();
         }
-        
+
         Producer createProducer() {
             return new BufferSkipProducer();
         }
-        
+
         final class BufferSkipProducer
         extends AtomicBoolean
         implements Producer {
@@ -233,18 +233,18 @@ public void request(long n) {
             }
         }
     }
-    
+
     static final class BufferOverlap<T> extends Subscriber<T> {
         final Subscriber<? super List<T>> actual;
         final int count;
         final int skip;
-        
+
         long index;
-        
+
         final ArrayDeque<List<T>> queue;
-        
+
         final AtomicLong requested;
-        
+
         long produced;
 
         public BufferOverlap(Subscriber<? super List<T>> actual, int count, int skip) {
@@ -269,11 +269,11 @@ public void onNext(T t) {
             } else {
                 index = i;
             }
-            
+
             for (List<T> list : queue) {
                 list.add(t);
             }
-            
+
             List<T> b = queue.peek();
             if (b != null && b.size() == count) {
                 queue.poll();
@@ -281,18 +281,18 @@ public void onNext(T t) {
                 actual.onNext(b);
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             queue.clear();
-            
+
             actual.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             long p = produced;
-            
+
             if (p != 0L) {
                 if (p > requested.get()) {
                     actual.onError(new MissingBackpressureException("More produced than requested? " + p));
@@ -300,14 +300,14 @@ public void onCompleted() {
                 }
                 requested.addAndGet(-p);
             }
-            
+
             BackpressureUtils.postCompleteDone(requested, queue, actual);
         }
-        
+
         Producer createProducer() {
             return new BufferOverlapProducer();
         }
-        
+
         final class BufferOverlapProducer extends AtomicBoolean implements Producer {
 
             /** */
@@ -321,7 +321,7 @@ public void request(long n) {
                         if (!get() && compareAndSet(false, true)) {
                             long u = BackpressureUtils.multiplyCap(parent.skip, n - 1);
                             long v = BackpressureUtils.addCap(u, parent.count);
-                            
+
                             parent.request(v);
                         } else {
                             long u = BackpressureUtils.multiplyCap(parent.skip, n);
@@ -330,7 +330,7 @@ public void request(long n) {
                     }
                 }
             }
-            
+
         }
     }
 }
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java b/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
index 383a82b3d8..405cf27c1d 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
@@ -41,7 +41,7 @@
  * Note that when using this operation <strong>multiple overlapping chunks</strong> could be active at any
  * one point.
  * </p>
- * 
+ *
  * @param <T> the buffered value type
  * @param <TOpening> the value type of the Observable opening buffers
  * @param <TClosing> the value type of the Observable closing buffers
@@ -66,9 +66,9 @@ public OperatorBufferWithStartEndObservable(Observable<? extends TOpening> buffe
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
-        
+
         final BufferingSubscriber bsub = new BufferingSubscriber(new SerializedSubscriber<List<T>>(child));
-        
+
         Subscriber<TOpening> openSubscriber = new Subscriber<TOpening>() {
 
             @Override
@@ -85,13 +85,13 @@ public void onError(Throwable e) {
             public void onCompleted() {
                 bsub.onCompleted();
             }
-            
+
         };
         child.add(openSubscriber);
         child.add(bsub);
-        
+
         bufferOpening.unsafeSubscribe(openSubscriber);
-        
+
         return bsub;
     }
     final class BufferingSubscriber extends Subscriber<T> {
@@ -185,10 +185,10 @@ public void onCompleted() {
                     closingSubscriptions.remove(this);
                     endBuffer(chunk);
                 }
-                
+
             };
             closingSubscriptions.add(closeSubscriber);
-            
+
             cobs.unsafeSubscribe(closeSubscriber);
         }
         void endBuffer(List<T> toEnd) {
@@ -211,6 +211,6 @@ void endBuffer(List<T> toEnd) {
                 child.onNext(toEnd);
             }
         }
-        
+
     }
 }
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithTime.java b/src/main/java/rx/internal/operators/OperatorBufferWithTime.java
index 76fd0ba37b..8184a1fa77 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithTime.java
@@ -37,7 +37,7 @@
  * Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
  * on the input parameters.
  * </p>
- * 
+ *
  * @param <T> the buffered value type
  */
 public final class OperatorBufferWithTime<T> implements Operator<List<T>, T> {
@@ -71,7 +71,7 @@ public OperatorBufferWithTime(long timespan, long timeshift, TimeUnit unit, int
     public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
         final Worker inner = scheduler.createWorker();
         SerializedSubscriber<List<T>> serialized = new SerializedSubscriber<List<T>>(child);
-        
+
         if (timespan == timeshift) {
             ExactSubscriber bsub = new ExactSubscriber(serialized, inner);
             bsub.add(inner);
@@ -79,7 +79,7 @@ public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
             bsub.scheduleExact();
             return bsub;
         }
-        
+
         InexactSubscriber bsub = new InexactSubscriber(serialized, inner);
         bsub.add(inner);
         child.add(bsub);
diff --git a/src/main/java/rx/internal/operators/OperatorCast.java b/src/main/java/rx/internal/operators/OperatorCast.java
index e5b2f76176..ed2d517036 100644
--- a/src/main/java/rx/internal/operators/OperatorCast.java
+++ b/src/main/java/rx/internal/operators/OperatorCast.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -39,24 +39,24 @@ public Subscriber<? super T> call(final Subscriber<? super R> o) {
         o.add(parent);
         return parent;
     }
-    
+
     static final class CastSubscriber<T, R> extends Subscriber<T> {
-        
+
         final Subscriber<? super R> actual;
-        
+
         final Class<R> castClass;
 
         boolean done;
-        
+
         public CastSubscriber(Subscriber<? super R> actual, Class<R> castClass) {
             this.actual = actual;
             this.castClass = castClass;
         }
-        
+
         @Override
         public void onNext(T t) {
             R result;
-            
+
             try {
                 result = castClass.cast(t);
             } catch (Throwable ex) {
@@ -65,10 +65,10 @@ public void onNext(T t) {
                 onError(OnErrorThrowable.addValueAsLastCause(ex, t));
                 return;
             }
-            
+
             actual.onNext(result);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             if (done) {
@@ -76,11 +76,11 @@ public void onError(Throwable e) {
                 return;
             }
             done = true;
-            
+
             actual.onError(e);
         }
-        
-        
+
+
         @Override
         public void onCompleted() {
             if (done) {
@@ -88,7 +88,7 @@ public void onCompleted() {
             }
             actual.onCompleted();
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             actual.setProducer(p);
diff --git a/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java b/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java
index e530d38a66..310473d854 100644
--- a/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java
+++ b/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java
@@ -25,47 +25,47 @@
 
 /**
  * Delay the emission via another observable if no new source appears in the meantime.
- * 
+ *
  * @param <T> the value type of the main sequence
  * @param <U> the value type of the boundary sequence
  */
 public final class OperatorDebounceWithSelector<T, U> implements Operator<T, T> {
     final Func1<? super T, ? extends Observable<U>> selector;
-    
+
     public OperatorDebounceWithSelector(Func1<? super T, ? extends Observable<U>> selector) {
         this.selector = selector;
     }
-    
+
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
         final SerialSubscription ssub = new SerialSubscription();
         child.add(ssub);
-        
+
         return new Subscriber<T>(child) {
             final DebounceState<T> state = new DebounceState<T>();
             final Subscriber<?> self = this;
-            
+
             @Override
             public void onStart() {
                 // debounce wants to receive everything as a firehose without backpressure
                 request(Long.MAX_VALUE);
             }
-            
+
             @Override
             public void onNext(T t) {
                 Observable<U> debouncer;
-                
+
                 try {
                     debouncer = selector.call(t);
                 } catch (Throwable e) {
                     Exceptions.throwOrReport(e, this);
                     return;
                 }
-                
-                
+
+
                 final int index = state.next(t);
-                
+
                 Subscriber<U> debounceSubscriber = new Subscriber<U>() {
 
                     @Override
@@ -85,9 +85,9 @@ public void onCompleted() {
                     }
                 };
                 ssub.set(debounceSubscriber);
-                
+
                 debouncer.unsafeSubscribe(debounceSubscriber);
-                
+
             }
 
             @Override
@@ -103,5 +103,5 @@ public void onCompleted() {
             }
         };
     }
-    
+
 }
\ No newline at end of file
diff --git a/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java b/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
index 874f9c9e54..dc8e5d59e0 100644
--- a/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
@@ -50,16 +50,16 @@ public OperatorDebounceWithTime(long timeout, TimeUnit unit, Scheduler scheduler
         this.unit = unit;
         this.scheduler = scheduler;
     }
-    
+
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         final Worker worker = scheduler.createWorker();
         final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
         final SerialSubscription ssub = new SerialSubscription();
-        
+
         s.add(worker);
         s.add(ssub);
-        
+
         return new Subscriber<T>(child) {
             final DebounceState<T> state = new DebounceState<T>();
             final Subscriber<?> self = this;
@@ -71,7 +71,7 @@ public void onStart() {
 
             @Override
             public void onNext(final T t) {
-                
+
                 final int index = state.next(t);
                 ssub.set(worker.schedule(new Action0() {
                     @Override
@@ -80,14 +80,14 @@ public void call() {
                     }
                 }, timeout, unit));
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 s.onError(e);
                 unsubscribe();
                 state.clear();
             }
-            
+
             @Override
             public void onCompleted() {
                 state.emitAndComplete(s, this);
@@ -109,8 +109,8 @@ static final class DebounceState<T> {
         boolean terminate;
         /** Guarded by this. */
         boolean emitting;
-        
-        public synchronized int next(T value) { // NOPMD 
+
+        public synchronized int next(T value) { // NOPMD
             this.value = value;
             this.hasValue = true;
             return ++index;
@@ -122,7 +122,7 @@ public void emit(int index, Subscriber<T> onNextAndComplete, Subscriber<?> onErr
                     return;
                 }
                 localValue = value;
-                
+
                 value = null;
                 hasValue = false;
                 emitting = true;
@@ -142,13 +142,13 @@ public void emit(int index, Subscriber<T> onNextAndComplete, Subscriber<?> onErr
                     return;
                 }
             }
-            
+
             onNextAndComplete.onCompleted();
         }
         public void emitAndComplete(Subscriber<T> onNextAndComplete, Subscriber<?> onError) {
             T localValue;
             boolean localHasValue;
-            
+
             synchronized (this) {
                 if (emitting) {
                     terminate = true;
@@ -156,7 +156,7 @@ public void emitAndComplete(Subscriber<T> onNextAndComplete, Subscriber<?> onErr
                 }
                 localValue = value;
                 localHasValue = hasValue;
-                
+
                 value = null;
                 hasValue = false;
 
@@ -173,7 +173,7 @@ public void emitAndComplete(Subscriber<T> onNextAndComplete, Subscriber<?> onErr
             }
             onNextAndComplete.onCompleted();
         }
-        public synchronized void clear() { // NOPMD 
+        public synchronized void clear() { // NOPMD
             ++index;
             value = null;
             hasValue = false;
diff --git a/src/main/java/rx/internal/operators/OperatorDelay.java b/src/main/java/rx/internal/operators/OperatorDelay.java
index 35d23cf9c1..ef271ae37e 100644
--- a/src/main/java/rx/internal/operators/OperatorDelay.java
+++ b/src/main/java/rx/internal/operators/OperatorDelay.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -24,7 +24,7 @@
 
 /**
  * Delays the emission of onNext events by a given amount of time.
- * 
+ *
  * @param <T>
  *            the value type
  */
diff --git a/src/main/java/rx/internal/operators/OperatorDelayWithSelector.java b/src/main/java/rx/internal/operators/OperatorDelayWithSelector.java
index 7211b18586..8b34096dcc 100644
--- a/src/main/java/rx/internal/operators/OperatorDelayWithSelector.java
+++ b/src/main/java/rx/internal/operators/OperatorDelayWithSelector.java
@@ -24,7 +24,7 @@
 
 /**
  * Delay the subscription and emission of the source items by a per-item observable that fires its first element.
- * 
+ *
  * @param <T>
  *            the item type
  * @param <V>
diff --git a/src/main/java/rx/internal/operators/OperatorDematerialize.java b/src/main/java/rx/internal/operators/OperatorDematerialize.java
index d7b27b094d..3065a6dd76 100644
--- a/src/main/java/rx/internal/operators/OperatorDematerialize.java
+++ b/src/main/java/rx/internal/operators/OperatorDematerialize.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -25,7 +25,7 @@
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/dematerialize.png" alt="">
  * <p>
  * See <a href="http://msdn.microsoft.com/en-us/library/hh229047.aspx">here</a> for the Microsoft Rx equivalent.
- * 
+ *
  * @param <T> the wrapped value type
  */
 public final class OperatorDematerialize<T> implements Operator<T, Notification<T>> {
@@ -41,10 +41,10 @@ static final class Holder {
     public static OperatorDematerialize instance() {
         return Holder.INSTANCE; // using raw types because the type inference is not good enough
     }
-    OperatorDematerialize() { 
+    OperatorDematerialize() {
         // singleton
     }
-    
+
     @Override
     public Subscriber<? super Notification<T>> call(final Subscriber<? super T> child) {
         return new Subscriber<Notification<T>>(child) {
@@ -85,8 +85,8 @@ public void onCompleted() {
                     child.onCompleted();
                 }
             }
-            
+
         };
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/operators/OperatorDistinct.java b/src/main/java/rx/internal/operators/OperatorDistinct.java
index 551cd741f9..04f41e1133 100644
--- a/src/main/java/rx/internal/operators/OperatorDistinct.java
+++ b/src/main/java/rx/internal/operators/OperatorDistinct.java
@@ -24,23 +24,23 @@
 
 /**
  * Returns an Observable that emits all distinct items emitted by the source.
- * 
+ *
  * @param <T> the value type
  * @param <U> the key type
  */
 public final class OperatorDistinct<T, U> implements Operator<T, T> {
     final Func1<? super T, ? extends U> keySelector;
-    
+
     static final class Holder {
         static final OperatorDistinct<?,?> INSTANCE = new OperatorDistinct<Object,Object>(UtilityFunctions.<Object>identity());
     }
-    
+
     /**
-     * Returns a singleton instance of OperatorDistinct that was built using 
+     * Returns a singleton instance of OperatorDistinct that was built using
      * the identity function for comparison (<code>new OperatorDistinct(UtilityFunctions.identity())</code>).
-     * 
+     *
      * @param <T> the value type
-     * @return Operator that emits distinct values only (regardless of order) using the identity function for comparison 
+     * @return Operator that emits distinct values only (regardless of order) using the identity function for comparison
      */
     @SuppressWarnings("unchecked")
     public static <T> OperatorDistinct<T, T> instance() {
@@ -77,7 +77,7 @@ public void onCompleted() {
                 keyMemory = null;
                 child.onCompleted();
             }
-            
+
         };
     }
 }
diff --git a/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java b/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
index 9d75db915d..9b41ced8fd 100644
--- a/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
+++ b/src/main/java/rx/internal/operators/OperatorDistinctUntilChanged.java
@@ -28,20 +28,20 @@
  */
 public final class OperatorDistinctUntilChanged<T, U> implements Operator<T, T>, Func2<U, U, Boolean> {
     final Func1<? super T, ? extends U> keySelector;
-    
+
     final Func2<? super U, ? super U, Boolean> comparator;
-    
+
     static final class Holder {
         static final OperatorDistinctUntilChanged<?,?> INSTANCE = new OperatorDistinctUntilChanged<Object,Object>(UtilityFunctions.identity());
     }
-    
+
 
     /**
-     * Returns a singleton instance of OperatorDistinctUntilChanged that was built using 
+     * Returns a singleton instance of OperatorDistinctUntilChanged that was built using
      * the identity function for comparison (<code>new OperatorDistinctUntilChanged(UtilityFunctions.identity())</code>).
-     * 
+     *
      * @param <T> the value type
-     * @return Operator that emits sequentially distinct values only using the identity function for comparison 
+     * @return Operator that emits sequentially distinct values only using the identity function for comparison
      */
     @SuppressWarnings("unchecked")
     public static <T> OperatorDistinctUntilChanged<T, T> instance() {
@@ -51,7 +51,7 @@ public static <T> OperatorDistinctUntilChanged<T, T> instance() {
     public OperatorDistinctUntilChanged(Func1<? super T, ? extends U> keySelector) {
         this.keySelector = keySelector;
         this.comparator = this;
-        
+
     }
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
@@ -59,7 +59,7 @@ public OperatorDistinctUntilChanged(Func2<? super U, ? super U, Boolean> compara
         this.keySelector = (Func1)UtilityFunctions.identity();
         this.comparator = comparator;
     }
-    
+
     @Override
     public Boolean call(U t1, U t2) {
         return (t1 == t2 || (t1 != null && t1.equals(t2)));
@@ -81,17 +81,17 @@ public void onNext(T t) {
                 }
                 U currentKey = previousKey;
                 previousKey = key;
-                
+
                 if (hasPrevious) {
                     boolean comparison;
-                    
+
                     try {
                         comparison = comparator.call(currentKey, key);
                     } catch (Throwable e) {
                         Exceptions.throwOrReport(e, child, key);
                         return;
                     }
-                    
+
                     if (!comparison) {
                         child.onNext(t);
                     } else {
@@ -112,8 +112,8 @@ public void onError(Throwable e) {
             public void onCompleted() {
                 child.onCompleted();
             }
-            
+
         };
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/operators/OperatorDoAfterTerminate.java b/src/main/java/rx/internal/operators/OperatorDoAfterTerminate.java
index a3efa8f845..c53bb51756 100644
--- a/src/main/java/rx/internal/operators/OperatorDoAfterTerminate.java
+++ b/src/main/java/rx/internal/operators/OperatorDoAfterTerminate.java
@@ -28,7 +28,7 @@
  * <p>
  * See also the <a href="http://msdn.microsoft.com/en-us/library/hh212133.aspx">MSDN Observable.Finally
  * method</a>
- * 
+ *
  * @param <T> the value type
  */
 public final class OperatorDoAfterTerminate<T> implements Operator<T, T> {
@@ -67,7 +67,7 @@ public void onCompleted() {
                     callAction();
                 }
             }
-            
+
             void callAction() {
                 try {
                     action.call();
@@ -78,5 +78,5 @@ void callAction() {
             }
         };
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/operators/OperatorDoOnRequest.java b/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
index c350105d08..c8da34ac5d 100644
--- a/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
+++ b/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
@@ -20,9 +20,9 @@
 import rx.functions.Action1;
 
 /**
- * This operator modifies an {@link rx.Observable} so a given action is invoked when the 
+ * This operator modifies an {@link rx.Observable} so a given action is invoked when the
  * {@link rx.Producer} receives a request.
- * 
+ *
  * @param <T>
  *            The type of the elements in the {@link rx.Observable} that this operator modifies
  */
diff --git a/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java b/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java
index a779720396..c16dbcdbdc 100644
--- a/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java
+++ b/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java
@@ -37,20 +37,20 @@ public OperatorEagerConcatMap(Func1<? super T, ? extends Observable<? extends R>
         this.bufferSize = bufferSize;
         this.maxConcurrent = maxConcurrent;
     }
-    
+
     @Override
     public Subscriber<? super T> call(Subscriber<? super R> t) {
         EagerOuterSubscriber<T, R> outer = new EagerOuterSubscriber<T, R>(mapper, bufferSize, maxConcurrent, t);
         outer.init();
         return outer;
     }
-    
+
     static final class EagerOuterProducer extends AtomicLong implements Producer {
         /** */
         private static final long serialVersionUID = -657299606803478389L;
-        
+
         final EagerOuterSubscriber<?, ?> parent;
-        
+
         public EagerOuterProducer(EagerOuterSubscriber<?, ?> parent) {
             this.parent = parent;
         }
@@ -60,29 +60,29 @@ public void request(long n) {
             if (n < 0) {
                 throw new IllegalStateException("n >= 0 required but it was " + n);
             }
-            
+
             if (n > 0) {
                 BackpressureUtils.getAndAddRequest(this, n);
                 parent.drain();
             }
         }
     }
-    
+
     static final class EagerOuterSubscriber<T, R> extends Subscriber<T> {
         final Func1<? super T, ? extends Observable<? extends R>> mapper;
         final int bufferSize;
         final Subscriber<? super R> actual;
-        
+
         final Queue<EagerInnerSubscriber<R>> subscribers;
-        
+
         volatile boolean done;
         Throwable error;
-        
+
         volatile boolean cancelled;
-        
+
         final AtomicInteger wip;
         private EagerOuterProducer sharedProducer;
-        
+
         public EagerOuterSubscriber(Func1<? super T, ? extends Observable<? extends R>> mapper, int bufferSize,
                 int maxConcurrent, Subscriber<? super R> actual) {
             this.mapper = mapper;
@@ -92,7 +92,7 @@ public EagerOuterSubscriber(Func1<? super T, ? extends Observable<? extends R>>
             this.wip = new AtomicInteger();
             request(maxConcurrent == Integer.MAX_VALUE ? Long.MAX_VALUE : maxConcurrent);
         }
-        
+
         void init() {
             sharedProducer = new EagerOuterProducer(this);
             add(Subscriptions.create(new Action0() {
@@ -107,36 +107,36 @@ public void call() {
             actual.add(this);
             actual.setProducer(sharedProducer);
         }
-        
+
         void cleanup() {
             List<Subscription> list;
             synchronized (subscribers) {
                 list = new ArrayList<Subscription>(subscribers);
                 subscribers.clear();
             }
-            
+
             for (Subscription s : list) {
                 s.unsubscribe();
             }
         }
-        
+
         @Override
         public void onNext(T t) {
             Observable<? extends R> observable;
-            
+
             try {
                 observable = mapper.call(t);
             } catch (Throwable e) {
                 Exceptions.throwOrReport(e, actual, t);
                 return;
             }
-            
+
             if (cancelled) {
                 return;
             }
-            
+
             EagerInnerSubscriber<R> inner = new EagerInnerSubscriber<R>(this, bufferSize);
-            
+
             synchronized (subscribers) {
                 if (cancelled) {
                     return;
@@ -149,45 +149,45 @@ public void onNext(T t) {
             observable.unsafeSubscribe(inner);
             drain();
         }
-        
+
         @Override
         public void onError(Throwable e) {
             error = e;
             done = true;
             drain();
         }
-        
+
         @Override
         public void onCompleted() {
             done = true;
             drain();
         }
-        
+
         void drain() {
             if (wip.getAndIncrement() != 0) {
                 return;
             }
             int missed = 1;
-            
+
             final AtomicLong requested = sharedProducer;
             final Subscriber<? super R> actualSubscriber = this.actual;
             final NotificationLite<R> nl = NotificationLite.instance();
-            
+
             for (;;) {
-                
+
                 if (cancelled) {
                     cleanup();
                     return;
                 }
-                
+
                 EagerInnerSubscriber<R> innerSubscriber;
-                
+
                 boolean outerDone = done;
                 synchronized (subscribers) {
                     innerSubscriber = subscribers.peek();
                 }
                 boolean empty = innerSubscriber == null;
-                
+
                 if (outerDone) {
                     Throwable error = this.error;
                     if (error != null) {
@@ -204,16 +204,16 @@ void drain() {
                 if (!empty) {
                     long requestedAmount = requested.get();
                     long emittedAmount = 0L;
-                    
+
                     Queue<Object> innerQueue = innerSubscriber.queue;
                     boolean innerDone = false;
-                    
-                    
+
+
                     for (;;) {
                         outerDone = innerSubscriber.done;
                         Object v = innerQueue.peek();
                         empty = v == null;
-                        
+
                         if (outerDone) {
                             Throwable innerError = innerSubscriber.error;
                             if (innerError != null) {
@@ -231,27 +231,27 @@ void drain() {
                                 break;
                             }
                         }
-                        
+
                         if (empty) {
                             break;
                         }
-                        
+
                         if (requestedAmount == emittedAmount) {
                             break;
                         }
-                        
+
                         innerQueue.poll();
-                        
+
                         try {
                             actualSubscriber.onNext(nl.getValue(v));
                         } catch (Throwable ex) {
                             Exceptions.throwOrReport(ex, actualSubscriber, v);
                             return;
                         }
-                        
+
                         emittedAmount++;
                     }
-                    
+
                     if (emittedAmount != 0L) {
                         if (requestedAmount != Long.MAX_VALUE) {
                             BackpressureUtils.produced(requested, emittedAmount);
@@ -260,12 +260,12 @@ void drain() {
                             innerSubscriber.requestMore(emittedAmount);
                         }
                     }
-                    
+
                     if (innerDone) {
                         continue;
                     }
                 }
-                
+
                 missed = wip.addAndGet(-missed);
                 if (missed == 0) {
                     return;
@@ -273,15 +273,15 @@ void drain() {
             }
         }
     }
-    
+
     static final class EagerInnerSubscriber<T> extends Subscriber<T> {
         final EagerOuterSubscriber<?, T> parent;
         final Queue<Object> queue;
         final NotificationLite<T> nl;
-        
+
         volatile boolean done;
         Throwable error;
-        
+
         public EagerInnerSubscriber(EagerOuterSubscriber<?, T> parent, int bufferSize) {
             super();
             this.parent = parent;
@@ -295,26 +295,26 @@ public EagerInnerSubscriber(EagerOuterSubscriber<?, T> parent, int bufferSize) {
             this.nl = NotificationLite.instance();
             request(bufferSize);
         }
-        
+
         @Override
         public void onNext(T t) {
             queue.offer(nl.next(t));
             parent.drain();
         }
-        
+
         @Override
         public void onError(Throwable e) {
             error = e;
             done = true;
             parent.drain();
         }
-        
+
         @Override
         public void onCompleted() {
             done = true;
             parent.drain();
         }
-        
+
         void requestMore(long n) {
             request(n);
         }
diff --git a/src/main/java/rx/internal/operators/OperatorElementAt.java b/src/main/java/rx/internal/operators/OperatorElementAt.java
index 4a8531af37..b8e8be3821 100644
--- a/src/main/java/rx/internal/operators/OperatorElementAt.java
+++ b/src/main/java/rx/internal/operators/OperatorElementAt.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -79,14 +79,14 @@ public void onCompleted() {
                     }
                 }
             }
-            
+
             @Override
             public void setProducer(Producer p) {
                 child.setProducer(new InnerProducer(p));
             }
         };
         child.add(parent);
-        
+
         return parent;
     }
     /**
@@ -96,9 +96,9 @@ public void setProducer(Producer p) {
     static class InnerProducer extends AtomicBoolean implements Producer {
         /** */
         private static final long serialVersionUID = 1L;
-        
+
         final Producer actual;
-        
+
         public InnerProducer(Producer actual) {
             this.actual = actual;
         }
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index 61f1bef9b1..6b475619a5 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -49,7 +49,7 @@ public final class OperatorGroupBy<T, K, V> implements Operator<GroupedObservabl
     final int bufferSize;
     final boolean delayError;
     final Func1<Action1<K>, Map<K, Object>> mapFactory; //nullable
-    
+
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public OperatorGroupBy(Func1<? super T, ? extends K> keySelector) {
         this(keySelector, (Func1)UtilityFunctions.<T>identity(), RxRingBuffer.SIZE, false, null);
@@ -58,7 +58,7 @@ public OperatorGroupBy(Func1<? super T, ? extends K> keySelector) {
     public OperatorGroupBy(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
         this(keySelector, valueSelector, RxRingBuffer.SIZE, false, null);
     }
-    
+
     public OperatorGroupBy(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func1<Action1<K>, Map<K, Object>> mapFactory) {
         this(keySelector, valueSelector, RxRingBuffer.SIZE, false, mapFactory);
     }
@@ -70,7 +70,7 @@ public OperatorGroupBy(Func1<? super T, ? extends K> keySelector, Func1<? super
         this.delayError = delayError;
         this.mapFactory = mapFactory;
     }
-    
+
     @Override
     public Subscriber<? super T> call(Subscriber<? super GroupedObservable<K, V>> child) {
         final GroupBySubscriber<T, K, V> parent; // NOPMD
@@ -92,13 +92,13 @@ public void call() {
         }));
 
         child.setProducer(parent.producer);
-        
+
         return parent;
     }
 
     public static final class GroupByProducer implements Producer {
         final GroupBySubscriber<?, ?, ?> parent;
-        
+
         public GroupByProducer(GroupBySubscriber<?, ?, ?> parent) {
             this.parent = parent;
         }
@@ -107,8 +107,8 @@ public void request(long n) {
             parent.requestMore(n);
         }
     }
-    
-    public static final class GroupBySubscriber<T, K, V> 
+
+    public static final class GroupBySubscriber<T, K, V>
     extends Subscriber<T> {
         final Subscriber<? super GroupedObservable<K, V>> actual;
         final Func1<? super T, ? extends K> keySelector;
@@ -119,24 +119,24 @@ public static final class GroupBySubscriber<T, K, V>
         final Queue<GroupedObservable<K, V>> queue;
         final GroupByProducer producer;
         final Queue<K> evictedKeys;
-        
+
         static final Object NULL_KEY = new Object();
-        
+
         final ProducerArbiter s;
-        
+
         final AtomicBoolean cancelled;
 
         final AtomicLong requested;
 
         final AtomicInteger groupCount;
-        
+
         Throwable error;
         volatile boolean done;
 
         final AtomicInteger wip;
-        
-        public GroupBySubscriber(Subscriber<? super GroupedObservable<K, V>> actual, Func1<? super T, ? extends K> keySelector, 
-                Func1<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError, 
+
+        public GroupBySubscriber(Subscriber<? super GroupedObservable<K, V>> actual, Func1<? super T, ? extends K> keySelector,
+                Func1<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError,
                 Func1<Action1<K>, Map<K, Object>> mapFactory) {
             this.actual = actual;
             this.keySelector = keySelector;
@@ -159,7 +159,7 @@ public GroupBySubscriber(Subscriber<? super GroupedObservable<K, V>> actual, Fun
                 this.groups = createMap(mapFactory, new EvictionAction<K>(evictedKeys));
             }
         }
-        
+
         static class EvictionAction<K> implements Action1<K> {
 
             final Queue<K> evictedKeys;
@@ -167,23 +167,23 @@ static class EvictionAction<K> implements Action1<K> {
             EvictionAction(Queue<K> evictedKeys) {
                 this.evictedKeys = evictedKeys;
             }
-            
+
             @Override
             public void call(K key) {
                 evictedKeys.offer(key);
             }
         }
-        
+
         @SuppressWarnings("unchecked")
         private Map<Object, GroupedUnicast<K, V>> createMap(Func1<Action1<K>, Map<K, Object>> mapFactory, Action1<K> evictionAction) {
             return (Map<Object, GroupedUnicast<K,V>>)(Map<Object, ?>) mapFactory.call(evictionAction);
         }
-        
+
         @Override
         public void setProducer(Producer s) {
             this.s.setProducer(s);
         }
-        
+
         @Override
         public void onNext(T t) {
             if (done) {
@@ -201,7 +201,7 @@ public void onNext(T t) {
                 errorAll(a, q, ex);
                 return;
             }
-            
+
             boolean notNew = true;
             Object mapKey = key != null ? key : NULL_KEY;
             GroupedUnicast<K, V> group = groups.get(mapKey);
@@ -211,9 +211,9 @@ public void onNext(T t) {
                 if (!cancelled.get()) {
                     group = GroupedUnicast.createWith(key, bufferSize, this, delayError);
                     groups.put(mapKey, group);
-                    
+
                     groupCount.getAndIncrement();
-                    
+
                     notNew = false;
                     q.offer(group);
                     drain();
@@ -221,7 +221,7 @@ public void onNext(T t) {
                     return;
                 }
             }
-            
+
             V v;
             try {
                 v = valueSelector.call(t);
@@ -232,7 +232,7 @@ public void onNext(T t) {
             }
 
             group.onNext(v);
-            
+
             if (evictedKeys != null) {
                 K evictedKey;
                 while ((evictedKey = evictedKeys.poll()) != null) {
@@ -247,7 +247,7 @@ public void onNext(T t) {
                 s.request(1);
             }
         }
-        
+
         @Override
         public void onError(Throwable t) {
             if (done) {
@@ -259,7 +259,7 @@ public void onError(Throwable t) {
             groupCount.decrementAndGet();
             drain();
         }
-        
+
         @Override
         public void onCompleted() {
             if (done) {
@@ -283,11 +283,11 @@ public void requestMore(long n) {
             if (n < 0) {
                 throw new IllegalArgumentException("n >= 0 required but it was " + n);
             }
-            
+
             BackpressureUtils.getAndAddRequest(requested, n);
             drain();
         }
-        
+
         public void cancel() {
             // cancelling the main source means we don't want any more groups
             // but running groups still require new values
@@ -297,7 +297,7 @@ public void cancel() {
                 }
             }
         }
-        
+
         public void cancel(K key) {
             Object mapKey = key != null ? key : NULL_KEY;
             if (groups.remove(mapKey) != null) {
@@ -306,76 +306,76 @@ public void cancel(K key) {
                 }
             }
         }
-        
+
         void drain() {
             if (wip.getAndIncrement() != 0) {
                 return;
             }
-            
+
             int missed = 1;
-            
+
             final Queue<GroupedObservable<K, V>> q = this.queue;
             final Subscriber<? super GroupedObservable<K, V>> a = this.actual;
-            
+
             for (;;) {
-                
+
                 if (checkTerminated(done, q.isEmpty(), a, q)) {
                     return;
                 }
-                
+
                 long r = requested.get();
                 long e = 0L;
-                
+
                 while (e != r) {
                     boolean d = done;
-                    
+
                     GroupedObservable<K, V> t = q.poll();
-                    
+
                     boolean empty = t == null;
-                    
+
                     if (checkTerminated(d, empty, a, q)) {
                         return;
                     }
-                    
+
                     if (empty) {
                         break;
                     }
 
                     a.onNext(t);
-                    
+
                     e++;
                 }
-                
+
                 if (e != 0L) {
                     if (r != Long.MAX_VALUE) {
                         BackpressureUtils.produced(requested, e);
                     }
                     s.request(e);
                 }
-                
+
                 missed = wip.addAndGet(-missed);
                 if (missed == 0) {
                     break;
                 }
             }
         }
-        
+
         void errorAll(Subscriber<? super GroupedObservable<K, V>> a, Queue<?> q, Throwable ex) {
             q.clear();
             List<GroupedUnicast<K, V>> list = new ArrayList<GroupedUnicast<K, V>>(groups.values());
             groups.clear();
-            if (evictedKeys != null) { 
+            if (evictedKeys != null) {
                 evictedKeys.clear();
             }
-            
+
             for (GroupedUnicast<K, V> e : list) {
                 e.onError(ex);
             }
-            
+
             a.onError(ex);
         }
-        
-        boolean checkTerminated(boolean d, boolean empty, 
+
+        boolean checkTerminated(boolean d, boolean empty,
                 Subscriber<? super GroupedObservable<K, V>> a, Queue<?> q) {
             if (d) {
                 Throwable err = error;
@@ -391,34 +391,34 @@ boolean checkTerminated(boolean d, boolean empty,
             return false;
         }
     }
-    
+
     static final class GroupedUnicast<K, T> extends GroupedObservable<K, T> {
         final State<T, K> state;
-        
-        
+
+
         public static <T, K> GroupedUnicast<K, T> createWith(K key, int bufferSize, GroupBySubscriber<?, K, T> parent, boolean delayError) {
             State<T, K> state = new State<T, K>(bufferSize, parent, key, delayError);
             return new GroupedUnicast<K, T>(key, state);
         }
-        
+
         protected GroupedUnicast(K key, State<T, K> state) {
             super(key, state);
             this.state = state;
         }
-        
+
         public void onNext(T t) {
             state.onNext(t);
         }
-        
+
         public void onError(Throwable e) {
             state.onError(e);
         }
-        
+
         public void onComplete() {
             state.onComplete();
         }
     }
-    
+
     static final class State<T, K> extends AtomicInteger implements Producer, Subscription, OnSubscribe<T> {
         /** */
         private static final long serialVersionUID = -3852313036005250360L;
@@ -427,20 +427,20 @@ static final class State<T, K> extends AtomicInteger implements Producer, Subscr
         final Queue<Object> queue;
         final GroupBySubscriber<?, K, T> parent;
         final boolean delayError;
-        
+
         final AtomicLong requested;
-        
+
         volatile boolean done;
         Throwable error;
-        
+
         final AtomicBoolean cancelled;
 
         final AtomicReference<Subscriber<? super T>> actual;
 
         final AtomicBoolean once;
 
-        
-        public State(int bufferSize, GroupBySubscriber<?, K, T> parent, K key, boolean delayError) { // NOPMD 
+
+        public State(int bufferSize, GroupBySubscriber<?, K, T> parent, K key, boolean delayError) { // NOPMD
             this.queue = new ConcurrentLinkedQueue<Object>();
             this.parent = parent;
             this.key = key;
@@ -450,7 +450,7 @@ public State(int bufferSize, GroupBySubscriber<?, K, T> parent, K key, boolean d
             this.once = new AtomicBoolean();
             this.requested = new AtomicLong();
         }
-        
+
         @Override
         public void request(long n) {
             if (n < 0) {
@@ -461,12 +461,12 @@ public void request(long n) {
                 drain();
             }
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return cancelled.get();
         }
-        
+
         @Override
         public void unsubscribe() {
             if (cancelled.compareAndSet(false, true)) {
@@ -475,7 +475,7 @@ public void unsubscribe() {
                 }
             }
         }
-        
+
         @Override
         public void call(Subscriber<? super T> s) {
             if (once.compareAndSet(false, true)) {
@@ -497,13 +497,13 @@ public void onNext(T t) {
             }
             drain();
         }
-        
+
         public void onError(Throwable e) {
             error = e;
             done = true;
             drain();
         }
-        
+
         public void onComplete() {
             done = true;
             drain();
@@ -514,7 +514,7 @@ void drain() {
                 return;
             }
             int missed = 1;
-            
+
             final Queue<Object> q = queue;
             final boolean delayError = this.delayError;
             Subscriber<? super T> a = actual.get();
@@ -524,28 +524,28 @@ void drain() {
                     if (checkTerminated(done, q.isEmpty(), a, delayError)) {
                         return;
                     }
-                    
+
                     long r = requested.get();
                     long e = 0;
-                    
+
                     while (e != r) {
                         boolean d = done;
                         Object v = q.poll();
                         boolean empty = v == null;
-                        
+
                         if (checkTerminated(d, empty, a, delayError)) {
                             return;
                         }
-                        
+
                         if (empty) {
                             break;
                         }
-                        
+
                         a.onNext(nl.getValue(v));
-                        
+
                         e++;
                     }
-                    
+
                     if (e != 0L) {
                         if (r != Long.MAX_VALUE) {
                             BackpressureUtils.produced(requested, e);
@@ -553,7 +553,7 @@ void drain() {
                         parent.s.request(e);
                     }
                 }
-                
+
                 missed = addAndGet(-missed);
                 if (missed == 0) {
                     break;
@@ -563,14 +563,14 @@ void drain() {
                 }
             }
         }
-        
+
         boolean checkTerminated(boolean d, boolean empty, Subscriber<? super T> a, boolean delayError) {
             if (cancelled.get()) {
                 queue.clear();
                 parent.cancel(key);
                 return true;
             }
-            
+
             if (d) {
                 if (delayError) {
                     if (empty) {
@@ -595,7 +595,7 @@ boolean checkTerminated(boolean d, boolean empty, Subscriber<? super T> a, boole
                     }
                 }
             }
-            
+
             return false;
         }
     }
diff --git a/src/main/java/rx/internal/operators/OperatorIgnoreElements.java b/src/main/java/rx/internal/operators/OperatorIgnoreElements.java
index b85fb54359..c5f441f393 100644
--- a/src/main/java/rx/internal/operators/OperatorIgnoreElements.java
+++ b/src/main/java/rx/internal/operators/OperatorIgnoreElements.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -23,7 +23,7 @@ public class OperatorIgnoreElements<T> implements Operator<T, T> {
     static final class Holder {
         static final OperatorIgnoreElements<?> INSTANCE = new OperatorIgnoreElements<Object>();
     }
-    
+
     @SuppressWarnings("unchecked")
     public static <T> OperatorIgnoreElements<T> instance() {
         return (OperatorIgnoreElements<T>) Holder.INSTANCE;
diff --git a/src/main/java/rx/internal/operators/OperatorMapNotification.java b/src/main/java/rx/internal/operators/OperatorMapNotification.java
index 77f85d04ad..3316bb4911 100644
--- a/src/main/java/rx/internal/operators/OperatorMapNotification.java
+++ b/src/main/java/rx/internal/operators/OperatorMapNotification.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -54,17 +54,17 @@ public void request(long n) {
         });
         return parent;
     }
-    
+
     static final class MapNotificationSubscriber<T, R> extends Subscriber<T> {
-        
+
         final Subscriber<? super R> actual;
-        
+
         final Func1<? super T, ? extends R> onNext;
-        
+
         final Func1<? super Throwable, ? extends R> onError;
-        
+
         final Func0<? extends R> onCompleted;
-        
+
         final AtomicLong requested;
 
         final AtomicLong missedRequested;
@@ -72,12 +72,12 @@ static final class MapNotificationSubscriber<T, R> extends Subscriber<T> {
         final AtomicReference<Producer> producer;
 
         long produced;
-        
+
         R value;
-        
+
         static final long COMPLETED_FLAG = Long.MIN_VALUE;
         static final long REQUESTED_MASK = Long.MAX_VALUE;
-        
+
         public MapNotificationSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> onNext,
                 Func1<? super Throwable, ? extends R> onError, Func0<? extends R> onCompleted) {
             this.actual = actual;
@@ -98,7 +98,7 @@ public void onNext(T t) {
                 Exceptions.throwOrReport(ex, actual, t);
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             accountProduced();
@@ -109,7 +109,7 @@ public void onError(Throwable e) {
             }
             tryEmit();
         }
-        
+
         @Override
         public void onCompleted() {
             accountProduced();
@@ -120,14 +120,14 @@ public void onCompleted() {
             }
             tryEmit();
         }
-        
+
         void accountProduced() {
             long p = produced;
             if (p != 0L && producer.get() != null) {
                 BackpressureUtils.produced(requested, p);
             }
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             if (producer.compareAndSet(null, p)) {
@@ -139,7 +139,7 @@ public void setProducer(Producer p) {
                 throw new IllegalStateException("Producer already set!");
             }
         }
-        
+
         void tryEmit() {
             for (;;) {
                 long r = requested.get();
@@ -159,7 +159,7 @@ void tryEmit() {
                 }
             }
         }
-        
+
         void requestInner(long n) {
             if (n < 0L) {
                 throw new IllegalArgumentException("n >= 0 required but it was " + n);
@@ -169,7 +169,7 @@ void requestInner(long n) {
             }
             for (;;) {
                 long r = requested.get();
-                
+
                 if ((r & COMPLETED_FLAG) != 0L) {
                     long v = r & REQUESTED_MASK;
                     long u = BackpressureUtils.addCap(v, n) | COMPLETED_FLAG;
@@ -191,7 +191,7 @@ void requestInner(long n) {
                     }
                 }
             }
-            
+
             AtomicReference<Producer> localProducer = producer;
             Producer actualProducer = localProducer.get();
             if (actualProducer != null) {
diff --git a/src/main/java/rx/internal/operators/OperatorMapPair.java b/src/main/java/rx/internal/operators/OperatorMapPair.java
index c4f65605d3..94389d6799 100644
--- a/src/main/java/rx/internal/operators/OperatorMapPair.java
+++ b/src/main/java/rx/internal/operators/OperatorMapPair.java
@@ -39,7 +39,7 @@ public final class OperatorMapPair<T, U, R> implements Operator<Observable<? ext
 
     /**
      * Creates the function that generates a {@code Observable} based on an item emitted by another {@code Observable}.
-     * 
+     *
      * @param <T> the input value type
      * @param <U> the value type of the generated Observable
      * @param selector
@@ -67,29 +67,29 @@ public Subscriber<? super T> call(final Subscriber<? super Observable<? extends
         o.add(parent);
         return parent;
     }
-    
+
     static final class MapPairSubscriber<T, U, R> extends Subscriber<T> {
-        
+
         final Subscriber<? super Observable<? extends R>> actual;
-        
+
         final Func1<? super T, ? extends Observable<? extends U>> collectionSelector;
         final Func2<? super T, ? super U, ? extends R> resultSelector;
 
         boolean done;
-        
-        public MapPairSubscriber(Subscriber<? super Observable<? extends R>> actual, 
+
+        public MapPairSubscriber(Subscriber<? super Observable<? extends R>> actual,
                 Func1<? super T, ? extends Observable<? extends U>> collectionSelector,
                         Func2<? super T, ? super U, ? extends R> resultSelector) {
             this.actual = actual;
             this.collectionSelector = collectionSelector;
             this.resultSelector = resultSelector;
         }
-        
+
         @Override
         public void onNext(T outer) {
-            
+
             Observable<? extends U> intermediate;
-            
+
             try {
                 intermediate = collectionSelector.call(outer);
             } catch (Throwable ex) {
@@ -98,10 +98,10 @@ public void onNext(T outer) {
                 onError(OnErrorThrowable.addValueAsLastCause(ex, outer));
                 return;
             }
-            
+
             actual.onNext(intermediate.map(new OuterInnerMapper<T, U, R>(outer, resultSelector)));
         }
-        
+
         @Override
         public void onError(Throwable e) {
             if (done) {
@@ -109,11 +109,11 @@ public void onError(Throwable e) {
                 return;
             }
             done = true;
-            
+
             actual.onError(e);
         }
-        
-        
+
+
         @Override
         public void onCompleted() {
             if (done) {
@@ -121,7 +121,7 @@ public void onCompleted() {
             }
             actual.onCompleted();
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             actual.setProducer(p);
@@ -136,11 +136,11 @@ public OuterInnerMapper(T outer, Func2<? super T, ? super U, ? extends R> result
             this.outer = outer;
             this.resultSelector = resultSelector;
         }
-        
+
         @Override
         public R call(U inner) {
             return resultSelector.call(outer, inner);
         }
-       
+
     }
 }
\ No newline at end of file
diff --git a/src/main/java/rx/internal/operators/OperatorMaterialize.java b/src/main/java/rx/internal/operators/OperatorMaterialize.java
index aebecf5029..c1d4a3b65e 100644
--- a/src/main/java/rx/internal/operators/OperatorMaterialize.java
+++ b/src/main/java/rx/internal/operators/OperatorMaterialize.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -71,7 +71,7 @@ static class ParentSubscriber<T> extends Subscriber<T> {
         private final Subscriber<? super Notification<T>> child;
 
         private volatile Notification<T> terminalNotification;
-        
+
         // guarded by this
         private boolean busy;
         // guarded by this
@@ -133,7 +133,7 @@ private void drain() {
                     // set flag to force extra loop if drain loop running
                     missed = true;
                     return;
-                } 
+                }
             }
             // drain loop
             final AtomicLong localRequested = this.requested;
diff --git a/src/main/java/rx/internal/operators/OperatorMerge.java b/src/main/java/rx/internal/operators/OperatorMerge.java
index a5d92a33ae..0cd46ea608 100644
--- a/src/main/java/rx/internal/operators/OperatorMerge.java
+++ b/src/main/java/rx/internal/operators/OperatorMerge.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -105,10 +105,10 @@ public Subscriber<Observable<? extends T>> call(final Subscriber<? super T> chil
         MergeSubscriber<T> subscriber = new MergeSubscriber<T>(child, delayErrors, maxConcurrent);
         MergeProducer<T> producer = new MergeProducer<T>(subscriber);
         subscriber.producer = producer;
-        
+
         child.add(subscriber);
         child.setProducer(producer);
-        
+
         return subscriber;
     }
 
@@ -117,11 +117,11 @@ static final class MergeProducer<T> extends AtomicLong implements Producer {
         private static final long serialVersionUID = -1214379189873595503L;
 
         final MergeSubscriber<T> subscriber;
-        
+
         public MergeProducer(MergeSubscriber<T> subscriber) {
             this.subscriber = subscriber;
         }
-        
+
         @Override
         public void request(long n) {
             if (n > 0) {
@@ -130,7 +130,7 @@ public void request(long n) {
                 }
                 BackpressureUtils.getAndAddRequest(this, n);
                 subscriber.emit();
-            } else 
+            } else
             if (n < 0) {
                 throw new IllegalArgumentException("n >= 0 required");
             }
@@ -139,53 +139,53 @@ public long produced(int n) {
             return addAndGet(-n);
         }
     }
-    
+
     /**
-     * The subscriber that observes Observables. 
+     * The subscriber that observes Observables.
      * @param <T> the value type
      */
     static final class MergeSubscriber<T> extends Subscriber<Observable<? extends T>> {
         final Subscriber<? super T> child;
         final boolean delayErrors;
         final int maxConcurrent;
-        
+
         MergeProducer<T> producer;
-        
+
         volatile Queue<Object> queue;
-        
+
         /** Tracks the active subscriptions to sources. */
         volatile CompositeSubscription subscriptions;
         /** Due to the emission loop, we need to store errors somewhere if !delayErrors. */
         volatile ConcurrentLinkedQueue<Throwable> errors;
-        
+
         final NotificationLite<T> nl;
-        
+
         volatile boolean done;
-        
+
         /** Guarded by this. */
         boolean emitting;
         /** Guarded by this. */
         boolean missed;
-        
+
         final Object innerGuard;
         /** Copy-on-write array, guarded by innerGuard. */
         volatile InnerSubscriber<?>[] innerSubscribers;
-        
+
         /** Used to generate unique InnerSubscriber IDs. Modified from onNext only. */
         long uniqueId;
-        
+
         /** Which was the last InnerSubscriber that emitted? Accessed if emitting == true. */
         long lastId;
         /** What was its index in the innerSubscribers array? Accessed if emitting == true. */
         int lastIndex;
-        
-        /** An empty array to avoid creating new empty arrays in removeInner. */ 
+
+        /** An empty array to avoid creating new empty arrays in removeInner. */
         static final InnerSubscriber<?>[] EMPTY = new InnerSubscriber<?>[0];
 
         final int scalarEmissionLimit;
-        
+
         int scalarEmissionCount;
-        
+
         public MergeSubscriber(Subscriber<? super T> child, boolean delayErrors, int maxConcurrent) {
             this.child = child;
             this.delayErrors = delayErrors;
@@ -201,7 +201,7 @@ public MergeSubscriber(Subscriber<? super T> child, boolean delayErrors, int max
                 request(maxConcurrent);
             }
         }
-        
+
         Queue<Throwable> getOrCreateErrorQueue() {
             ConcurrentLinkedQueue<Throwable> q = errors;
             if (q == null) {
@@ -233,7 +233,7 @@ CompositeSubscription getOrCreateComposite() {
             }
             return c;
         }
-        
+
         @Override
         public void onNext(Observable<? extends T> t) {
             if (t == null) {
@@ -251,7 +251,7 @@ public void onNext(Observable<? extends T> t) {
                 emit();
             }
         }
-        
+
         void emitEmpty() {
             int produced = scalarEmissionCount + 1;
             if (produced == scalarEmissionLimit) {
@@ -261,7 +261,7 @@ void emitEmpty() {
                 scalarEmissionCount = produced;
             }
         }
-        
+
         private void reportError() {
             List<Throwable> list = new ArrayList<Throwable>(errors);
             if (list.size() == 1) {
@@ -270,7 +270,7 @@ private void reportError() {
                 child.onError(new CompositeException(list));
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             getOrCreateErrorQueue().offer(e);
@@ -282,7 +282,7 @@ public void onCompleted() {
             done = true;
             emit();
         }
-        
+
         void addInner(InnerSubscriber<T> inner) {
             getOrCreateComposite().add(inner);
             synchronized (innerGuard) {
@@ -326,7 +326,7 @@ void removeInner(InnerSubscriber<T> inner) {
                 innerSubscribers = b;
             }
         }
-        
+
         /**
          * Tries to emit the value directly to the child if
          * no concurrent emission is happening at the moment.
@@ -334,7 +334,7 @@ void removeInner(InnerSubscriber<T> inner) {
          * Since the scalar-value queue optimization applies
          * to both the main source and the inner subscribers,
          * we handle things in a shared manner.
-         * 
+         *
          * @param subscriber
          * @param value
          */
@@ -431,7 +431,7 @@ protected void emitScalar(InnerSubscriber<T> subscriber, T value, long r) {
              * In the synchronized block below request(1) we check
              * if there was a concurrent emission attempt and if there was,
              * we stay in emission mode and enter the emission loop
-             * which will take care all the queued up state and 
+             * which will take care all the queued up state and
              * emission possibilities.
              */
             emitLoop();
@@ -440,7 +440,7 @@ protected void emitScalar(InnerSubscriber<T> subscriber, T value, long r) {
         public void requestMore(long n) {
             request(n);
         }
-        
+
         /**
          * Tries to emit the value directly to the child if
          * no concurrent emission is happening at the moment.
@@ -448,7 +448,7 @@ public void requestMore(long n) {
          * Since the scalar-value queue optimization applies
          * to both the main source and the inner subscribers,
          * we handle things in a shared manner.
-         * 
+         *
          * @param subscriber
          * @param value
          */
@@ -528,7 +528,7 @@ protected void emitScalar(T value, long r) {
                 if (r != Long.MAX_VALUE) {
                     producer.produced(1);
                 }
-                
+
                 int produced = scalarEmissionCount + 1;
                 if (produced == scalarEmissionLimit) {
                     scalarEmissionCount = 0;
@@ -536,7 +536,7 @@ protected void emitScalar(T value, long r) {
                 } else {
                     scalarEmissionCount = produced;
                 }
-                
+
                 // check if some state changed while emitting
                 synchronized (this) {
                     skipFinal = true;
@@ -557,12 +557,12 @@ protected void emitScalar(T value, long r) {
              * In the synchronized block below request(1) we check
              * if there was a concurrent emission attempt and if there was,
              * we stay in emission mode and enter the emission loop
-             * which will take care all the queued up state and 
+             * which will take care all the queued up state and
              * emission possibilities.
              */
             emitLoop();
         }
-        
+
         void emit() {
             synchronized (this) {
                 if (emitting) {
@@ -587,10 +587,10 @@ void emitLoop() {
                         return;
                     }
                     Queue<Object> svq = queue;
-                    
+
                     long r = producer.get();
                     boolean unbounded = r == Long.MAX_VALUE;
-                    
+
                     // count the number of 'completed' sources to replenish them in batches
                     int replenishMain = 0;
 
@@ -653,8 +653,8 @@ void emitLoop() {
                     // read the current set of inner subscribers
                     InnerSubscriber<?>[] inner = innerSubscribers;
                     int n = inner.length;
-                    
-                    // check if upstream is done, there are no scalar values 
+
+                    // check if upstream is done, there are no scalar values
                     // and no active inner subscriptions
                     if (d && (svq == null || svq.isEmpty()) && n == 0) {
                         Queue<Throwable> e = errors;
@@ -666,13 +666,13 @@ void emitLoop() {
                         skipFinal = true;
                         return;
                     }
-                    
+
                     boolean innerCompleted = false;
                     if (n > 0) {
                         // let's continue the round-robin emission from last location
                         long startId = lastId;
                         int index = lastIndex;
-                        
+
                         // in case there were changes in the array or the index
                         // no longer points to the inner with the cached id
                         if (n <= index || inner[index].id != startId) {
@@ -697,7 +697,7 @@ void emitLoop() {
                             lastIndex = j;
                             lastId = inner[j].id;
                         }
-                        
+
                         int j = index;
                         // loop through all sources once to avoid delaying any new sources too much
                         for (int i = 0; i < n; i++) {
@@ -708,7 +708,7 @@ void emitLoop() {
                             }
                             @SuppressWarnings("unchecked")
                             InnerSubscriber<T> is = (InnerSubscriber<T>)inner[j];
-                            
+
                             Object o = null;
                             for (;;) {
                                 int produced = 0;
@@ -771,7 +771,7 @@ void emitLoop() {
                             if (r == 0) {
                                 break;
                             }
-                            
+
                             // wrap around in round-robin fashion
                             j++;
                             if (j == n) {
@@ -782,7 +782,7 @@ void emitLoop() {
                         lastIndex = j;
                         lastId = inner[j].id;
                     }
-                    
+
                     if (replenishMain > 0) {
                         request(replenishMain);
                     }
@@ -808,7 +808,7 @@ void emitLoop() {
                 }
             }
         }
-        
+
         /**
          * Check if the operator reached some terminal state: child unsubscribed,
          * an error was reported and we don't delay errors.
@@ -837,7 +837,7 @@ static final class InnerSubscriber<T> extends Subscriber<T> {
         volatile RxRingBuffer queue;
         int outstanding;
         static final int LIMIT = RxRingBuffer.SIZE / 4;
-        
+
         public InnerSubscriber(MergeSubscriber<T> parent, long id) {
             this.parent = parent;
             this.id = id;
diff --git a/src/main/java/rx/internal/operators/OperatorMulticast.java b/src/main/java/rx/internal/operators/OperatorMulticast.java
index c728fdc465..dfed4b49cc 100644
--- a/src/main/java/rx/internal/operators/OperatorMulticast.java
+++ b/src/main/java/rx/internal/operators/OperatorMulticast.java
@@ -28,7 +28,7 @@
 
 /**
  * Shares a single subscription to a source through a Subject.
- * 
+ *
  * @param <T>
  *            the source value type
  * @param <R>
@@ -110,7 +110,7 @@ public void call() {
                     }
                 }));
                 guardedSubscription = gs.get();
-                
+
                 // register any subscribers that are waiting with this new subject
                 for(final Subscriber<? super R> s : waitingForConnect) {
                     subject.unsafeSubscribe(new Subscriber<R>(s) {
@@ -133,7 +133,7 @@ public void onCompleted() {
                 // record the Subject so OnSubscribe can see it
                 connectedSubject.set(subject);
             }
-            
+
         }
 
         // in the lock above we determined we should subscribe, do it now outside the lock
@@ -142,7 +142,7 @@ public void onCompleted() {
 
         // now that everything is hooked up let's subscribe
         // as long as the subscription is not null (which can happen if already unsubscribed)
-        Subscriber<T> sub; 
+        Subscriber<T> sub;
         synchronized (guard) {
             sub = subscription;
         }
diff --git a/src/main/java/rx/internal/operators/OperatorObserveOn.java b/src/main/java/rx/internal/operators/OperatorObserveOn.java
index 57145ec27a..b037758478 100644
--- a/src/main/java/rx/internal/operators/OperatorObserveOn.java
+++ b/src/main/java/rx/internal/operators/OperatorObserveOn.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -31,9 +31,9 @@
 
 /**
  * Delivers events on the specified {@code Scheduler} asynchronously via an unbounded buffer.
- * 
+ *
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/observeOn.png" alt="">
- * 
+ *
  * @param <T>
  *            the transmitted value type
  */
@@ -76,7 +76,7 @@ public Subscriber<? super T> call(Subscriber<? super T> child) {
             return parent;
         }
     }
-    
+
     public static <T> Operator<T, T> rebatch(final int n) {
         return new Operator<T, T>() {
             @Override
@@ -97,20 +97,20 @@ static final class ObserveOnSubscriber<T> extends Subscriber<T> implements Actio
         final Queue<Object> queue;
         /** The emission threshold that should trigger a replenishing request. */
         final int limit;
-        
+
         // the status of the current stream
         volatile boolean finished;
 
         final AtomicLong requested = new AtomicLong();
-        
+
         final AtomicLong counter = new AtomicLong();
-        
-        /** 
+
+        /**
          * The single exception if not null, should be written before setting finished (release) and read after
          * reading finished (acquire).
          */
         Throwable error;
-        
+
         /** Remembers how many elements have been emitted before the requests run out. */
         long emitted;
 
@@ -132,12 +132,12 @@ public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> child, boo
             // signal that this is an async operator capable of receiving this many
             request(calculatedSize);
         }
-        
+
         void init() {
-            // don't want this code in the constructor because `this` can escape through the 
+            // don't want this code in the constructor because `this` can escape through the
             // setProducer call
             Subscriber<? super T> localChild = child;
-            
+
             localChild.setProducer(new Producer() {
 
                 @Override
@@ -203,27 +203,27 @@ public void call() {
             final Queue<Object> q = this.queue;
             final Subscriber<? super T> localChild = this.child;
             final NotificationLite<T> localOn = this.on;
-            
+
             // requested and counter are not included to avoid JIT issues with register spilling
             // and their access is is amortized because they are part of the outer loop which runs
             // less frequently (usually after each bufferSize elements)
-            
+
             for (;;) {
                 long requestAmount = requested.get();
-                
+
                 while (requestAmount != currentEmission) {
                     boolean done = finished;
                     Object v = q.poll();
                     boolean empty = v == null;
-                    
+
                     if (checkTerminated(done, empty, localChild, q)) {
                         return;
                     }
-                    
+
                     if (empty) {
                         break;
                     }
-                    
+
                     localChild.onNext(localOn.getValue(v));
 
                     currentEmission++;
@@ -233,7 +233,7 @@ public void call() {
                         currentEmission = 0L;
                     }
                 }
-                
+
                 if (requestAmount == currentEmission) {
                     if (checkTerminated(finished, q.isEmpty(), localChild, q)) {
                         return;
@@ -247,13 +247,13 @@ public void call() {
                 }
             }
         }
-        
+
         boolean checkTerminated(boolean done, boolean isEmpty, Subscriber<? super T> a, Queue<Object> q) {
             if (a.isUnsubscribed()) {
                 q.clear();
                 return true;
             }
-            
+
             if (done) {
                 if (delayError) {
                     if (isEmpty) {
@@ -288,9 +288,9 @@ boolean checkTerminated(boolean done, boolean isEmpty, Subscriber<? super T> a,
                         return true;
                     }
                 }
-                    
+
             }
-            
+
             return false;
         }
     }
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
index 3a9f8f2b4b..c93e5756b1 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -114,7 +114,7 @@ static final class BufferSubscriber<T> extends Subscriber<T> implements Backpres
         private final NotificationLite<T> on = NotificationLite.instance();
         private final Action0 onOverflow;
         private final Strategy overflowStrategy;
-        
+
         public BufferSubscriber(final Subscriber<? super T> child, Long capacity, Action0 onOverflow,
                                 Strategy overflowStrategy) {
             this.child = child;
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
index 80254abf57..1cea49ef48 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -63,9 +63,9 @@ public void request(long n) {
 
         });
         return new Subscriber<T>(child) {
-            
+
             boolean done;
-            
+
             @Override
             public void onStart() {
                 request(Long.MAX_VALUE);
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java
index 230ec153e1..cffb7de326 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureLatest.java
@@ -30,7 +30,7 @@ public final class OperatorOnBackpressureLatest<T> implements Operator<T, T> {
     static final class Holder {
         static final OperatorOnBackpressureLatest<Object> INSTANCE = new OperatorOnBackpressureLatest<Object>();
     }
-    
+
     /**
      * Returns a singleton instance of the OnBackpressureLatest operator since it is stateless.
      * @param <T> the value type
@@ -40,7 +40,7 @@ static final class Holder {
     public static <T> OperatorOnBackpressureLatest<T> instance() {
         return (OperatorOnBackpressureLatest<T>)Holder.INSTANCE;
     }
-    
+
     @Override
     public Subscriber<? super T> call(Subscriber<? super T> child) {
         final LatestEmitter<T> producer = new LatestEmitter<T>(child);
@@ -73,7 +73,7 @@ static final class LatestEmitter<T> extends AtomicLong implements Producer, Subs
         public LatestEmitter(Subscriber<? super T> child) {
             this.child = child;
             this.value = new AtomicReference<Object>(EMPTY);
-            this.lazySet(NOT_REQUESTED); // not 
+            this.lazySet(NOT_REQUESTED); // not
         }
         @Override
         public void request(long n) {
@@ -124,7 +124,7 @@ public void unsubscribe() {
                 getAndSet(Long.MIN_VALUE);
             }
         }
-        
+
         @Override
         public void onNext(T t) {
             value.lazySet(t); // emit's synchronized block does a full release
@@ -203,7 +203,7 @@ static final class LatestSubscriber<T> extends Subscriber<T> {
         @Override
         public void onStart() {
             // don't run until the child actually requested to avoid synchronous problems
-            request(0); 
+            request(0);
         }
 
         @Override
diff --git a/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java b/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
index bbda214290..4a3b941447 100644
--- a/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
+++ b/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -83,15 +83,15 @@ public OperatorOnErrorResumeNextViaFunction(Func1<? super Throwable, ? extends O
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         final ProducerArbiter pa = new ProducerArbiter();
-        
+
         final SerialSubscription ssub = new SerialSubscription();
-        
+
         Subscriber<T> parent = new Subscriber<T>() {
 
             private boolean done;
-        
+
             long produced;
-            
+
             @Override
             public void onCompleted() {
                 if (done) {
@@ -131,14 +131,14 @@ public void setProducer(Producer producer) {
                         }
                     };
                     ssub.set(next);
-                    
+
                     long p = produced;
                     if (p != 0L) {
                         pa.produced(p);
                     }
-                    
+
                     Observable<? extends T> resume = resumeFunction.call(e);
-                    
+
                     resume.unsafeSubscribe(next);
                 } catch (Throwable e2) {
                     Exceptions.throwOrReport(e2, child);
@@ -153,7 +153,7 @@ public void onNext(T t) {
                 produced++;
                 child.onNext(t);
             }
-            
+
             @Override
             public void setProducer(final Producer producer) {
                 pa.setProducer(producer);
@@ -164,7 +164,7 @@ public void setProducer(final Producer producer) {
 
         child.add(ssub);
         child.setProducer(pa);
-        
+
         return parent;
     }
 
diff --git a/src/main/java/rx/internal/operators/OperatorPublish.java b/src/main/java/rx/internal/operators/OperatorPublish.java
index 1d5781a39f..bc7000baa6 100644
--- a/src/main/java/rx/internal/operators/OperatorPublish.java
+++ b/src/main/java/rx/internal/operators/OperatorPublish.java
@@ -28,7 +28,7 @@
 
 /**
  * A connectable observable which shares an underlying source and dispatches source values to subscribers in a backpressure-aware
- * manner. 
+ * manner.
  * @param <T> the value type
  */
 public final class OperatorPublish<T> extends ConnectableObservable<T> {
@@ -49,7 +49,7 @@ public static <T> ConnectableObservable<T> create(Observable<? extends T> source
         OnSubscribe<T> onSubscribe = new OnSubscribe<T>() {
             @Override
             public void call(Subscriber<? super T> child) {
-                // concurrent connection/disconnection may change the state, 
+                // concurrent connection/disconnection may change the state,
                 // we loop to be atomic while the child subscribes
                 for (;;) {
                     // get the current subscriber-to-source
@@ -62,18 +62,18 @@ public void call(Subscriber<? super T> child) {
                         u.init();
                         // let's try setting it as the current subscriber-to-source
                         if (!curr.compareAndSet(r, u)) {
-                            // didn't work, maybe someone else did it or the current subscriber 
+                            // didn't work, maybe someone else did it or the current subscriber
                             // to source has just finished
                             continue;
                         }
                         // we won, let's use it going onwards
                         r = u;
                     }
-                    
+
                     // create the backpressure-managing producer for this child
                     InnerProducer<T> inner = new InnerProducer<T>(r, child);
                     /*
-                     * Try adding it to the current subscriber-to-source, add is atomic in respect 
+                     * Try adding it to the current subscriber-to-source, add is atomic in respect
                      * to other adds and the termination of the subscriber-to-source.
                      */
                     if (!r.add(inner)) {
@@ -82,12 +82,12 @@ public void call(Subscriber<? super T> child) {
                          */
                         continue;
                         /*
-                         * Note: although technically correct, concurrent disconnects can cause 
-                         * unexpected behavior such as child subscribers never receiving anything 
-                         * (unless connected again). An alternative approach, similar to 
-                         * PublishSubject would be to immediately terminate such child 
+                         * Note: although technically correct, concurrent disconnects can cause
+                         * unexpected behavior such as child subscribers never receiving anything
+                         * (unless connected again). An alternative approach, similar to
+                         * PublishSubject would be to immediately terminate such child
                          * subscribers as well:
-                         * 
+                         *
                          * Object term = r.terminalEvent;
                          * if (r.nl.isCompleted(term)) {
                          *     child.onCompleted();
@@ -95,57 +95,57 @@ public void call(Subscriber<? super T> child) {
                          *     child.onError(r.nl.getError(term));
                          * }
                          * return;
-                         * 
+                         *
                          * The original concurrent behavior was non-deterministic in this regard as well.
                          * Allowing this behavior, however, may introduce another unexpected behavior:
                          * after disconnecting a previous connection, one might not be able to prepare
-                         * a new connection right after a previous termination by subscribing new child 
+                         * a new connection right after a previous termination by subscribing new child
                          * subscribers asynchronously before a connect call.
                          */
                     }
-                    // the producer has been registered with the current subscriber-to-source so 
+                    // the producer has been registered with the current subscriber-to-source so
                     // at least it will receive the next terminal event
                     child.add(inner);
-                    // setting the producer will trigger the first request to be considered by 
+                    // setting the producer will trigger the first request to be considered by
                     // the subscriber-to-source.
                     child.setProducer(inner);
-                    break; // NOPMD 
+                    break; // NOPMD
                 }
             }
         };
         return new OperatorPublish<T>(onSubscribe, source, curr);
     }
 
-    public static <T, R> Observable<R> create(final Observable<? extends T> source, 
+    public static <T, R> Observable<R> create(final Observable<? extends T> source,
             final Func1<? super Observable<T>, ? extends Observable<R>> selector) {
         return create(source, selector, false);
     }
-    
-    public static <T, R> Observable<R> create(final Observable<? extends T> source, 
+
+    public static <T, R> Observable<R> create(final Observable<? extends T> source,
             final Func1<? super Observable<T>, ? extends Observable<R>> selector, final boolean delayError) {
         return create(new OnSubscribe<R>() {
             @Override
             public void call(final Subscriber<? super R> child) {
                 final OnSubscribePublishMulticast<T> op = new OnSubscribePublishMulticast<T>(RxRingBuffer.SIZE, delayError);
-                
+
                 Subscriber<R> subscriber = new Subscriber<R>() {
                     @Override
                     public void onNext(R t) {
                         child.onNext(t);
                     }
-                    
+
                     @Override
                     public void onError(Throwable e) {
                         op.unsubscribe();
                         child.onError(e);
                     }
-                    
+
                     @Override
                     public void onCompleted() {
                         op.unsubscribe();
                         child.onCompleted();
                     }
-                    
+
                     @Override
                     public void setProducer(Producer p) {
                         child.setProducer(p);
@@ -154,15 +154,15 @@ public void setProducer(Producer p) {
 
                 child.add(op);
                 child.add(subscriber);
-                
+
                 selector.call(Observable.create(op)).unsafeSubscribe(subscriber);
-                
+
                 source.unsafeSubscribe(op.subscriber());
             }
         });
     }
 
-    private OperatorPublish(OnSubscribe<T> onSubscribe, Observable<? extends T> source, 
+    private OperatorPublish(OnSubscribe<T> onSubscribe, Observable<? extends T> source,
             final AtomicReference<PublishSubscriber<T>> current) {
         super(onSubscribe);
         this.source = source;
@@ -185,28 +185,28 @@ public void connect(Action1<? super Subscription> connection) {
                 u.init();
                 // try setting it as the current subscriber-to-source
                 if (!current.compareAndSet(ps, u)) {
-                    // did not work, perhaps a new subscriber arrived 
+                    // did not work, perhaps a new subscriber arrived
                     // and created a new subscriber-to-source as well, retry
                     continue;
                 }
                 ps = u;
             }
-            // if connect() was called concurrently, only one of them should actually 
+            // if connect() was called concurrently, only one of them should actually
             // connect to the source
             doConnect = !ps.shouldConnect.get() && ps.shouldConnect.compareAndSet(false, true);
-            break; // NOPMD 
+            break; // NOPMD
         }
-        /* 
+        /*
          * Notify the callback that we have a (new) connection which it can unsubscribe
          * but since ps is unique to a connection, multiple calls to connect() will return the
          * same Subscription and even if there was a connect-disconnect-connect pair, the older
          * references won't disconnect the newer connection.
          * Synchronous source consumers have the opportunity to disconnect via unsubscribe on the
          * Subscription as unsafeSubscribe may never return in its own.
-         * 
-         * Note however, that asynchronously disconnecting a running source might leave 
-         * child-subscribers without any terminal event; PublishSubject does not have this 
-         * issue because the unsubscription was always triggered by the child-subscribers 
+         *
+         * Note however, that asynchronously disconnecting a running source might leave
+         * child-subscribers without any terminal event; PublishSubject does not have this
+         * issue because the unsubscription was always triggered by the child-subscribers
          * themselves.
          */
         connection.call(ps);
@@ -214,7 +214,7 @@ public void connect(Action1<? super Subscription> connection) {
             source.unsafeSubscribe(ps);
         }
     }
-    
+
     @SuppressWarnings("rawtypes")
     static final class PublishSubscriber<T> extends Subscriber<T> implements Subscription {
         /** Holds notifications from upstream. */
@@ -225,36 +225,36 @@ static final class PublishSubscriber<T> extends Subscriber<T> implements Subscri
         final AtomicReference<PublishSubscriber<T>> current;
         /** Contains either an onCompleted or an onError token from upstream. */
         volatile Object terminalEvent;
-        
+
         /** Indicates an empty array of inner producers. */
         static final InnerProducer[] EMPTY = new InnerProducer[0];
         /** Indicates a terminated PublishSubscriber. */
         static final InnerProducer[] TERMINATED = new InnerProducer[0];
-        
+
         /** Tracks the subscribed producers. */
         final AtomicReference<InnerProducer[]> producers;
-        /** 
-         * Atomically changed from false to true by connect to make sure the 
-         * connection is only performed by one thread. 
+        /**
+         * Atomically changed from false to true by connect to make sure the
+         * connection is only performed by one thread.
          */
         final AtomicBoolean shouldConnect;
-        
+
         /** Guarded by this. */
         boolean emitting;
         /** Guarded by this. */
         boolean missed;
-        
+
         public PublishSubscriber(AtomicReference<PublishSubscriber<T>> current) {
-            this.queue = UnsafeAccess.isUnsafeAvailable() 
-                    ? new SpscArrayQueue<Object>(RxRingBuffer.SIZE) 
+            this.queue = UnsafeAccess.isUnsafeAvailable()
+                    ? new SpscArrayQueue<Object>(RxRingBuffer.SIZE)
                     : new SynchronizedQueue<Object>(RxRingBuffer.SIZE);
-            
+
             this.nl = NotificationLite.instance();
             this.producers = new AtomicReference<InnerProducer[]>(EMPTY);
             this.current = current;
             this.shouldConnect = new AtomicBoolean();
         }
-        
+
         /** Should be called after the constructor finished to setup nulling-out the current reference. */
         void init() {
             add(Subscriptions.create(new Action0() {
@@ -262,15 +262,15 @@ void init() {
                 public void call() {
                     PublishSubscriber.this.producers.getAndSet(TERMINATED);
                     current.compareAndSet(PublishSubscriber.this, null);
-                    // we don't care if it fails because it means the current has 
+                    // we don't care if it fails because it means the current has
                     // been replaced in the meantime
                 }
             }));
         }
-        
+
         @Override
         public void onStart() {
-            // since subscribers may have different amount of requests, we try to 
+            // since subscribers may have different amount of requests, we try to
             // optimize by buffering values up-front and replaying it on individual demand
             request(RxRingBuffer.SIZE);
         }
@@ -281,7 +281,7 @@ public void onNext(T t) {
             if (!queue.offer(nl.next(t))) {
                 onError(new MissingBackpressureException());
             } else {
-                // since many things can happen concurrently, we have a common dispatch 
+                // since many things can happen concurrently, we have a common dispatch
                 // loop to act on the current state serially
                 dispatch();
             }
@@ -292,7 +292,7 @@ public void onError(Throwable e) {
             // no need to CAS in the terminal value
             if (terminalEvent == null) {
                 terminalEvent = nl.error(e);
-                // since many things can happen concurrently, we have a common dispatch 
+                // since many things can happen concurrently, we have a common dispatch
                 // loop to act on the current state serially
                 dispatch();
             }
@@ -303,12 +303,12 @@ public void onCompleted() {
             // no need to CAS in the terminal value
             if (terminalEvent == null) {
                 terminalEvent = nl.completed();
-                // since many things can happen concurrently, we have a common dispatch loop 
+                // since many things can happen concurrently, we have a common dispatch loop
                 // to act on the current state serially
                 dispatch();
             }
         }
-        
+
         /**
          * Atomically try adding a new InnerProducer to this Subscriber or return false if this
          * Subscriber was terminated.
@@ -323,7 +323,7 @@ boolean add(InnerProducer<T> producer) {
             for (;;) {
                 // get the current producer array
                 InnerProducer[] c = producers.get();
-                // if this subscriber-to-source reached a terminal state by receiving 
+                // if this subscriber-to-source reached a terminal state by receiving
                 // an onError or onCompleted, just refuse to add the new producer
                 if (c == TERMINATED) {
                     return false;
@@ -341,7 +341,7 @@ boolean add(InnerProducer<T> producer) {
                 // so retry
             }
         }
-        
+
         /**
          * Atomically removes the given producer from the producers array.
          * @param producer the producer to remove
@@ -391,7 +391,7 @@ void remove(InnerProducer<T> producer) {
                 // (a concurrent add/remove or termination), we need to retry
             }
         }
-        
+
         /**
          * Perform termination actions in case the source has terminated in some way and
          * the queue has also become empty.
@@ -406,7 +406,7 @@ boolean checkTerminated(Object term, boolean empty) {
                 if (nl.isCompleted(term)) {
                     // but we also need to have an empty queue
                     if (empty) {
-                        // this will prevent OnSubscribe spinning on a terminated but 
+                        // this will prevent OnSubscribe spinning on a terminated but
                         // not yet unsubscribed PublishSubscriber
                         current.compareAndSet(this, null);
                         try {
@@ -414,7 +414,7 @@ boolean checkTerminated(Object term, boolean empty) {
                              * This will swap in a terminated array so add() in OnSubscribe will reject
                              * child subscribers to associate themselves with a terminated and thus
                              * never again emitting chain.
-                             * 
+                             *
                              * Since we atomically change the contents of 'producers' only one
                              * operation wins at a time. If an add() wins before this getAndSet,
                              * its value will be part of the returned array by getAndSet and thus
@@ -435,7 +435,7 @@ boolean checkTerminated(Object term, boolean empty) {
                     }
                 } else {
                     Throwable t = nl.getError(term);
-                    // this will prevent OnSubscribe spinning on a terminated 
+                    // this will prevent OnSubscribe spinning on a terminated
                     // but not yet unsubscribed PublishSubscriber
                     current.compareAndSet(this, null);
                     try {
@@ -457,7 +457,7 @@ boolean checkTerminated(Object term, boolean empty) {
             // there is still work to be done
             return false;
         }
-        
+
         /**
          * The common serialization point of events arriving from upstream and child-subscribers
          * requesting more.
@@ -509,7 +509,7 @@ void dispatch() {
                         skipFinal = true;
                         return;
                     }
-                    
+
                     // We have elements queued. Note that due to the serialization nature of dispatch()
                     // this loop is the only one which can turn a non-empty queue into an empty one
                     // and as such, no need to ask the queue itself again for that.
@@ -518,13 +518,13 @@ void dispatch() {
                         // Concurrent subscribers may miss this iteration, but it is to be expected
                         @SuppressWarnings("unchecked")
                         InnerProducer<T>[] ps = producers.get();
-                        
+
                         int len = ps.length;
                         // Let's assume everyone requested the maximum value.
                         long maxRequested = Long.MAX_VALUE;
                         // count how many have triggered unsubscription
                         int unsubscribed = 0;
-                    
+
                         // Now find the minimum amount each child-subscriber requested
                         // since we can only emit that much to all of them without violating
                         // backpressure constraints
@@ -541,7 +541,7 @@ void dispatch() {
                             }
                             // we ignore those with NOT_REQUESTED as if they aren't even there
                         }
-                        
+
                         // it may happen everyone has unsubscribed between here and producers.get()
                         // or we have no subscribers at all to begin with
                         if (len == unsubscribed) {
@@ -599,19 +599,19 @@ void dispatch() {
                             // indicate we emitted one element
                             d++;
                         }
-                        
+
                         // if we did emit at least one element, request more to replenish the queue
                         if (d > 0) {
                             request(d);
                         }
                         // if we have requests but not an empty queue after emission
-                        // let's try again to see if more requests/child-subscribers are 
+                        // let's try again to see if more requests/child-subscribers are
                         // ready to receive more
                         if (maxRequested != 0L && !empty) {
                             continue;
                         }
                     }
-                    
+
                     // we did what we could: either the queue is empty or child subscribers
                     // haven't requested more (or both), let's try to finish dispatching
                     synchronized (this) {
@@ -650,14 +650,14 @@ void dispatch() {
     static final class InnerProducer<T> extends AtomicLong implements Producer, Subscription {
         /** */
         private static final long serialVersionUID = -4453897557930727610L;
-        /** 
+        /**
          * The parent subscriber-to-source used to allow removing the child in case of
          * child unsubscription.
          */
         final PublishSubscriber<T> parent;
         /** The actual child subscriber. */
         final Subscriber<? super T> child;
-        /** 
+        /**
          * Indicates this child has been unsubscribed: the state is swapped in atomically and
          * will prevent the dispatch() to emit (too many) values to a terminated child subscriber.
          */
@@ -670,13 +670,13 @@ static final class InnerProducer<T> extends AtomicLong implements Producer, Subs
          * should not cause any problems.
          */
         static final long NOT_REQUESTED = Long.MIN_VALUE / 2;
-        
+
         public InnerProducer(PublishSubscriber<T> parent, Subscriber<? super T> child) {
             this.parent = parent;
             this.child = child;
             this.lazySet(NOT_REQUESTED);
         }
-        
+
         @Override
         public void request(long n) {
             // ignore negative requests
@@ -718,11 +718,11 @@ public void request(long n) {
                     parent.dispatch();
                     return;
                 }
-                // otherwise, someone else changed the state (perhaps a concurrent 
+                // otherwise, someone else changed the state (perhaps a concurrent
                 // request or unsubscription so retry
             }
         }
-        
+
         /**
          * Indicate that values have been emitted to this child subscriber by the dispatch() method.
          * @param n the number of items emitted
@@ -759,7 +759,7 @@ public long produced(long n) {
                 // otherwise, some concurrent activity happened and we need to retry
             }
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return get() == UNSUBSCRIBED;
diff --git a/src/main/java/rx/internal/operators/OperatorReplay.java b/src/main/java/rx/internal/operators/OperatorReplay.java
index 33e14b15de..b098304034 100644
--- a/src/main/java/rx/internal/operators/OperatorReplay.java
+++ b/src/main/java/rx/internal/operators/OperatorReplay.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -43,7 +43,7 @@ public Object call() {
             return new UnboundedReplayBuffer<Object>(16);
         }
     };
-    
+
     /**
      * Given a connectable observable factory, it multicasts over the generated
      * ConnectableObservable via a selector function.
@@ -70,9 +70,9 @@ public void call(final Subscriber<? super R> child) {
                     Exceptions.throwOrReport(e, child);
                     return;
                 }
-                
+
                 observable.subscribe(child);
-                
+
                 co.connect(new Action1<Subscription>() {
                     @Override
                     public void call(Subscription t) {
@@ -82,7 +82,7 @@ public void call(Subscription t) {
             }
         });
     }
-    
+
     /**
      * Child Subscribers will observe the events of the ConnectableObservable on the
      * specified scheduler.
@@ -120,7 +120,7 @@ public void connect(Action1<? super Subscription> connection) {
             }
         };
     }
-    
+
     /**
      * Creates a replaying ConnectableObservable with an unbounded buffer.
      * @param <T> the value type
@@ -131,7 +131,7 @@ public void connect(Action1<? super Subscription> connection) {
     public static <T> ConnectableObservable<T> create(Observable<? extends T> source) {
         return create(source, DEFAULT_UNBOUNDED_FACTORY);
     }
-    
+
     /**
      * Creates a replaying ConnectableObservable with a size bound buffer.
      * @param <T> the value type
@@ -140,7 +140,7 @@ public static <T> ConnectableObservable<T> create(Observable<? extends T> source
      * @return the replaying ConnectableObservable
      */
     @SuppressWarnings("cast")
-    public static <T> ConnectableObservable<T> create(Observable<? extends T> source, 
+    public static <T> ConnectableObservable<T> create(Observable<? extends T> source,
             final int bufferSize) {
         if (bufferSize == Integer.MAX_VALUE) {
             return (ConnectableObservable<T>)create(source);
@@ -163,7 +163,7 @@ public ReplayBuffer<T> call() {
      * @return the replaying ConnectableObservable
      */
     @SuppressWarnings("cast")
-    public static <T> ConnectableObservable<T> create(Observable<? extends T> source, 
+    public static <T> ConnectableObservable<T> create(Observable<? extends T> source,
             long maxAge, TimeUnit unit, Scheduler scheduler) {
         return (ConnectableObservable<T>)create(source, maxAge, unit, scheduler, Integer.MAX_VALUE);
     }
@@ -178,7 +178,7 @@ public static <T> ConnectableObservable<T> create(Observable<? extends T> source
      * @param bufferSize the maximum number of elements buffered
      * @return the replaying ConnectableObservable
      */
-    public static <T> ConnectableObservable<T> create(Observable<? extends T> source, 
+    public static <T> ConnectableObservable<T> create(Observable<? extends T> source,
             long maxAge, TimeUnit unit, final Scheduler scheduler, final int bufferSize) {
         final long maxAgeInMillis = unit.toMillis(maxAge);
         return create(source, new Func0<ReplayBuffer<T>>() {
@@ -195,14 +195,14 @@ public ReplayBuffer<T> call() {
      * @param bufferFactory the factory to instantiate the appropriate buffer when the observable becomes active
      * @return the connectable observable
      */
-    static <T> ConnectableObservable<T> create(Observable<? extends T> source, 
+    static <T> ConnectableObservable<T> create(Observable<? extends T> source,
             final Func0<? extends ReplayBuffer<T>> bufferFactory) {
         // the current connection to source needs to be shared between the operator and its onSubscribe call
         final AtomicReference<ReplaySubscriber<T>> curr = new AtomicReference<ReplaySubscriber<T>>();
         OnSubscribe<T> onSubscribe = new OnSubscribe<T>() {
             @Override
             public void call(Subscriber<? super T> child) {
-                // concurrent connection/disconnection may change the state, 
+                // concurrent connection/disconnection may change the state,
                 // we loop to be atomic while the child subscribes
                 for (;;) {
                     // get the current subscriber-to-source
@@ -215,37 +215,37 @@ public void call(Subscriber<? super T> child) {
                         u.init();
                         // let's try setting it as the current subscriber-to-source
                         if (!curr.compareAndSet(r, u)) {
-                            // didn't work, maybe someone else did it or the current subscriber 
+                            // didn't work, maybe someone else did it or the current subscriber
                             // to source has just finished
                             continue;
                         }
                         // we won, let's use it going onwards
                         r = u;
                     }
-                    
+
                     // create the backpressure-managing producer for this child
                     InnerProducer<T> inner = new InnerProducer<T>(r, child);
                     // we try to add it to the array of producers
                     // if it fails, no worries because we will still have its buffer
                     // so it is going to replay it for us
                     r.add(inner);
-                    // the producer has been registered with the current subscriber-to-source so 
+                    // the producer has been registered with the current subscriber-to-source so
                     // at least it will receive the next terminal event
                     child.add(inner);
-                    
+
                     // pin the head of the buffer here, shouldn't affect anything else
                     r.buffer.replay(inner);
-                    
-                    // setting the producer will trigger the first request to be considered by 
+
+                    // setting the producer will trigger the first request to be considered by
                     // the subscriber-to-source.
                     child.setProducer(inner);
-                    break; // NOPMD 
+                    break; // NOPMD
                 }
             }
         };
         return new OperatorReplay<T>(onSubscribe, source, curr, bufferFactory);
     }
-    private OperatorReplay(OnSubscribe<T> onSubscribe, Observable<? extends T> source, 
+    private OperatorReplay(OnSubscribe<T> onSubscribe, Observable<? extends T> source,
             final AtomicReference<ReplaySubscriber<T>> current,
             final Func0<? extends ReplayBuffer<T>> bufferFactory) {
         super(onSubscribe);
@@ -270,28 +270,28 @@ public void connect(Action1<? super Subscription> connection) {
                 u.init();
                 // try setting it as the current subscriber-to-source
                 if (!current.compareAndSet(ps, u)) {
-                    // did not work, perhaps a new subscriber arrived 
+                    // did not work, perhaps a new subscriber arrived
                     // and created a new subscriber-to-source as well, retry
                     continue;
                 }
                 ps = u;
             }
-            // if connect() was called concurrently, only one of them should actually 
+            // if connect() was called concurrently, only one of them should actually
             // connect to the source
             doConnect = !ps.shouldConnect.get() && ps.shouldConnect.compareAndSet(false, true);
-            break; // NOPMD 
+            break; // NOPMD
         }
-        /* 
+        /*
          * Notify the callback that we have a (new) connection which it can unsubscribe
          * but since ps is unique to a connection, multiple calls to connect() will return the
          * same Subscription and even if there was a connect-disconnect-connect pair, the older
          * references won't disconnect the newer connection.
          * Synchronous source consumers have the opportunity to disconnect via unsubscribe on the
          * Subscription as unsafeSubscribe may never return in its own.
-         * 
-         * Note however, that asynchronously disconnecting a running source might leave 
-         * child-subscribers without any terminal event; ReplaySubject does not have this 
-         * issue because the unsubscription was always triggered by the child-subscribers 
+         *
+         * Note however, that asynchronously disconnecting a running source might leave
+         * child-subscribers without any terminal event; ReplaySubject does not have this
+         * issue because the unsubscription was always triggered by the child-subscribers
          * themselves.
          */
         connection.call(ps);
@@ -299,7 +299,7 @@ public void connect(Action1<? super Subscription> connection) {
             source.unsafeSubscribe(ps);
         }
     }
-    
+
     @SuppressWarnings("rawtypes")
     static final class ReplaySubscriber<T> extends Subscriber<T> implements Subscription {
         /** Holds notifications from upstream. */
@@ -308,12 +308,12 @@ static final class ReplaySubscriber<T> extends Subscriber<T> implements Subscrip
         final NotificationLite<T> nl;
         /** Contains either an onCompleted or an onError token from upstream. */
         boolean done;
-        
+
         /** Indicates an empty array of inner producers. */
         static final InnerProducer[] EMPTY = new InnerProducer[0];
         /** Indicates a terminated ReplaySubscriber. */
         static final InnerProducer[] TERMINATED = new InnerProducer[0];
-        
+
         /** Indicates no further InnerProducers are accepted. */
         volatile boolean terminated;
         /** Tracks the subscribed producers. Guarded by itself. */
@@ -324,34 +324,34 @@ static final class ReplaySubscriber<T> extends Subscriber<T> implements Subscrip
         volatile long producersVersion;
         /** Contains the number of modifications that the producersCache holds. */
         long producersCacheVersion;
-        /** 
-         * Atomically changed from false to true by connect to make sure the 
-         * connection is only performed by one thread. 
+        /**
+         * Atomically changed from false to true by connect to make sure the
+         * connection is only performed by one thread.
          */
         final AtomicBoolean shouldConnect;
-        
+
         /** Guarded by this. */
         boolean emitting;
         /** Guarded by this. */
         boolean missed;
-        
-        
+
+
         /** Contains the maximum element index the child Subscribers requested so far. Accessed while emitting is true. */
         long maxChildRequested;
         /** Counts the outstanding upstream requests until the producer arrives. */
         long maxUpstreamRequested;
         /** The upstream producer. */
         volatile Producer producer;
-        
+
         /** The queue that holds producers with request changes that need to be coordinated. */
         List<InnerProducer<T>> coordinationQueue;
         /** Indicate that all request amounts should be considered. */
         boolean coordinateAll;
-        
+
         @SuppressWarnings("unchecked")
         public ReplaySubscriber(ReplayBuffer<T> buffer) {
             this.buffer = buffer;
-            
+
             this.nl = NotificationLite.instance();
             this.producers = new OpenHashSet<InnerProducer<T>>();
             this.producersCache = EMPTY;
@@ -377,7 +377,7 @@ public void call() {
                     // unlike OperatorPublish, we can't null out the terminated so
                     // late subscribers can still get replay
                     // current.compareAndSet(ReplaySubscriber.this, null);
-                    // we don't care if it fails because it means the current has 
+                    // we don't care if it fails because it means the current has
                     // been replaced in the meantime
                 }
             }));
@@ -399,13 +399,13 @@ boolean add(InnerProducer<T> producer) {
                 if (terminated) {
                     return false;
                 }
-                
+
                 producers.add(producer);
                 producersVersion++;
             }
             return true;
         }
-        
+
         /**
          * Atomically removes the given producer from the producers array.
          * @param producer the producer to remove
@@ -426,7 +426,7 @@ void remove(InnerProducer<T> producer) {
                 producersVersion++;
             }
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             Producer p0 = producer;
@@ -437,7 +437,7 @@ public void setProducer(Producer p) {
             manageRequests(null);
             replay();
         }
-        
+
         @Override
         public void onNext(T t) {
             if (!done) {
@@ -473,7 +473,7 @@ public void onCompleted() {
                 }
             }
         }
-        
+
         /**
          * Coordinates the request amounts of various child Subscribers.
          */
@@ -499,10 +499,10 @@ void manageRequests(InnerProducer<T> inner) {
                 }
                 emitting = true;
             }
-            
+
             long ri = maxChildRequested;
             long maxTotalRequested;
-            
+
             if (inner != null) {
                 maxTotalRequested = Math.max(ri, inner.totalRequested.get());
             } else {
@@ -514,16 +514,16 @@ void manageRequests(InnerProducer<T> inner) {
                         maxTotalRequested = Math.max(maxTotalRequested, rp.totalRequested.get());
                     }
                 }
-                
+
             }
             makeRequest(maxTotalRequested, ri);
-            
+
             for (;;) {
                 // if the upstream has completed, no more requesting is possible
                 if (isUnsubscribed()) {
                     return;
                 }
-                
+
                 List<InnerProducer<T>> q;
                 boolean all;
                 synchronized (this) {
@@ -537,7 +537,7 @@ void manageRequests(InnerProducer<T> inner) {
                     all = coordinateAll;
                     coordinateAll = false;
                 }
-                
+
                 ri = maxChildRequested;
                 maxTotalRequested = ri;
 
@@ -545,8 +545,8 @@ void manageRequests(InnerProducer<T> inner) {
                     for (InnerProducer<T> rp : q) {
                         maxTotalRequested = Math.max(maxTotalRequested, rp.totalRequested.get());
                     }
-                } 
-                
+                }
+
                 if (all) {
                     InnerProducer<T>[] a = copyProducers();
                     for (InnerProducer<T> rp : a) {
@@ -555,11 +555,11 @@ void manageRequests(InnerProducer<T> inner) {
                         }
                     }
                 }
-                
+
                 makeRequest(maxTotalRequested, ri);
             }
         }
-        
+
         InnerProducer<T>[] copyProducers() {
             synchronized (producers) {
                 Object[] a = producers.values();
@@ -570,7 +570,7 @@ InnerProducer<T>[] copyProducers() {
                 return result;
             }
         }
-        
+
         void makeRequest(long maxTotalRequests, long previousTotalRequests) {
             long ur = maxUpstreamRequested;
             Producer p = producer;
@@ -601,7 +601,7 @@ void makeRequest(long maxTotalRequests, long previousTotalRequests) {
                 p.request(ur);
             }
         }
-        
+
         /**
          * Tries to replay the buffer contents to all known subscribers.
          */
@@ -641,16 +641,16 @@ void replay() {
     static final class InnerProducer<T> extends AtomicLong implements Producer, Subscription {
         /** */
         private static final long serialVersionUID = -4453897557930727610L;
-        /** 
+        /**
          * The parent subscriber-to-source used to allow removing the child in case of
          * child unsubscription.
          */
         final ReplaySubscriber<T> parent;
         /** The actual child subscriber. */
         Subscriber<? super T> child;
-        /** 
+        /**
          * Holds an object that represents the current location in the buffer.
-         * Guarded by the emitter loop. 
+         * Guarded by the emitter loop.
          */
         Object index;
         /**
@@ -661,18 +661,18 @@ static final class InnerProducer<T> extends AtomicLong implements Producer, Subs
         boolean emitting;
         /** Indicates a missed update. Guarded by this. */
         boolean missed;
-        /** 
+        /**
          * Indicates this child has been unsubscribed: the state is swapped in atomically and
          * will prevent the dispatch() to emit (too many) values to a terminated child subscriber.
          */
         static final long UNSUBSCRIBED = Long.MIN_VALUE;
-        
+
         public InnerProducer(ReplaySubscriber<T> parent, Subscriber<? super T> child) {
             this.parent = parent;
             this.child = child;
             this.totalRequested = new AtomicLong();
         }
-        
+
         @Override
         public void request(long n) {
             // ignore negative requests
@@ -707,15 +707,15 @@ public void request(long n) {
                     // if successful, notify the parent dispatcher this child can receive more
                     // elements
                     parent.manageRequests(this);
-                    
+
                     parent.buffer.replay(this);
                     return;
                 }
-                // otherwise, someone else changed the state (perhaps a concurrent 
+                // otherwise, someone else changed the state (perhaps a concurrent
                 // request or unsubscription so retry
             }
         }
-        
+
         /**
          * Increments the total requested amount.
          * @param n the additional request amount
@@ -732,7 +732,7 @@ void addTotalRequested(long n) {
                 }
             }
         }
-        
+
         /**
          * Indicate that values have been emitted to this child subscriber by the dispatch() method.
          * @param n the number of items emitted
@@ -764,7 +764,7 @@ public long produced(long n) {
                 // otherwise, some concurrent activity happened and we need to retry
             }
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return get() == UNSUBSCRIBED;
@@ -831,7 +831,7 @@ interface ReplayBuffer<T> {
          */
         void replay(InnerProducer<T> output);
     }
-    
+
     /**
      * Holds an unbounded list of events.
      *
@@ -843,7 +843,7 @@ static final class UnboundedReplayBuffer<T> extends ArrayList<Object> implements
         final NotificationLite<T> nl;
         /** The total number of events in the buffer. */
         volatile int size;
-        
+
         public UnboundedReplayBuffer(int capacityHint) {
             super(capacityHint);
             nl = NotificationLite.instance();
@@ -880,10 +880,10 @@ public void replay(InnerProducer<T> output) {
                     return;
                 }
                 int sourceIndex = size;
-                
+
                 Integer destIndexObject = output.index();
                 int destIndex = destIndexObject != null ? destIndexObject : 0;
-                
+
                 Subscriber<? super T> child = output.child;
                 if (child == null) {
                     return;
@@ -891,7 +891,7 @@ public void replay(InnerProducer<T> output) {
 
                 long r = output.get();
                 long e = 0L;
-                
+
                 while (e != r && destIndex < sourceIndex) {
                     Object o = get(destIndex);
                     try {
@@ -918,7 +918,7 @@ public void replay(InnerProducer<T> output) {
                         output.produced(e);
                     }
                 }
-                
+
                 synchronized (output) {
                     if (!output.missed) {
                         output.emitting = false;
@@ -929,25 +929,25 @@ public void replay(InnerProducer<T> output) {
             }
         }
     }
-    
+
     /**
      * Represents a node in a bounded replay buffer's linked list.
      */
     static final class Node extends AtomicReference<Node> {
         /** */
         private static final long serialVersionUID = 245354315435971818L;
-        
+
         /** The contained value. */
         final Object value;
         /** The absolute index of the value. */
         final long index;
-        
+
         public Node(Object value, long index) {
             this.value = value;
             this.index = index;
         }
     }
-    
+
     /**
      * Base class for bounded buffering with options to specify an
      * enter and leave transforms and custom truncation behavior.
@@ -958,20 +958,20 @@ static class BoundedReplayBuffer<T> extends AtomicReference<Node> implements Rep
         /** */
         private static final long serialVersionUID = 2346567790059478686L;
         final NotificationLite<T> nl;
-        
+
         Node tail;
         int size;
-        
+
         /** The total number of received values so far. */
         long index;
-        
+
         public BoundedReplayBuffer() {
             nl = NotificationLite.instance();
             Node n = new Node(null, 0);
             tail = n;
             set(n);
         }
-        
+
         /**
          * Add a new node to the linked list.
          * @param n
@@ -1002,7 +1002,7 @@ final void removeFirst() {
                 n--;
                 size--;
             }
-            
+
             setFirst(head);
         }
         /**
@@ -1012,7 +1012,7 @@ final void removeFirst() {
         final void setFirst(Node n) {
             set(n);
         }
-        
+
         /**
          * Returns the current head for initializing the replay location
          * for a new subscriber.
@@ -1022,7 +1022,7 @@ final void setFirst(Node n) {
         Node getInitialHead() {
             return get();
         }
-        
+
         @Override
         public final void next(T value) {
             Object o = enterTransform(nl.next(value));
@@ -1065,7 +1065,7 @@ public final void replay(InnerProducer<T> output) {
                 if (node == null) {
                     node = getInitialHead();
                     output.index = node;
-                    
+
                     /*
                      * Since this is a latecommer, fix its total requested amount
                      * as if it got all the values up to the node.index
@@ -1119,7 +1119,7 @@ public final void replay(InnerProducer<T> output) {
                         output.produced(e);
                     }
                 }
-                
+
                 synchronized (output) {
                     if (!output.missed) {
                         output.emitting = false;
@@ -1128,9 +1128,9 @@ public final void replay(InnerProducer<T> output) {
                     output.missed = false;
                 }
             }
-            
+
         }
-        
+
         /**
          * Override this to wrap the NotificationLite object into a
          * container to be used later by truncate.
@@ -1187,7 +1187,7 @@ void truncateFinal() {
             return tail.value != null && nl.isCompleted(leaveTransform(tail.value));
         }
     }
-    
+
     /**
      * A bounded replay buffer implementation with size limit only.
      *
@@ -1196,12 +1196,12 @@ void truncateFinal() {
     static final class SizeBoundReplayBuffer<T> extends BoundedReplayBuffer<T> {
         /** */
         private static final long serialVersionUID = -5898283885385201806L;
-        
+
         final int limit;
         public SizeBoundReplayBuffer(int limit) {
             this.limit = limit;
         }
-        
+
         @Override
         void truncate() {
             // overflow can be at most one element
@@ -1209,13 +1209,13 @@ void truncate() {
                 removeFirst();
             }
         }
-        
+
         // no need for final truncation because values are truncated one by one
     }
-    
+
     /**
      * Size and time bound replay buffer.
-     * 
+     *
      * @param <T> the buffered value type
      */
     static final class SizeAndTimeBoundReplayBuffer<T> extends BoundedReplayBuffer<T> {
@@ -1229,38 +1229,38 @@ public SizeAndTimeBoundReplayBuffer(int limit, long maxAgeInMillis, Scheduler sc
             this.limit = limit;
             this.maxAgeInMillis = maxAgeInMillis;
         }
-        
+
         @Override
         Object enterTransform(Object value) {
             return new Timestamped<Object>(scheduler.now(), value);
         }
-        
+
         @Override
         Object leaveTransform(Object value) {
             return ((Timestamped<?>)value).getValue();
         }
-        
+
         @Override
         Node getInitialHead() {
             long timeLimit = scheduler.now() - maxAgeInMillis;
             Node prev = get();
-            
+
             Node next = prev.get();
             while (next != null && ((Timestamped<?>)next.value).getTimestampMillis() <= timeLimit) {
                 prev = next;
                 next = next.get();
             }
-            
+
             return prev;
         }
-        
+
         @Override
         void truncate() {
             long timeLimit = scheduler.now() - maxAgeInMillis;
-            
+
             Node prev = get();
             Node next = prev.get();
-            
+
             int e = 0;
             for (;;) {
                 if (next != null) {
@@ -1291,10 +1291,10 @@ void truncate() {
         @Override
         void truncateFinal() {
             long timeLimit = scheduler.now() - maxAgeInMillis;
-            
+
             Node prev = get();
             Node next = prev.get();
-            
+
             int e = 0;
             for (;;) {
                 if (next != null && size > 1) {
diff --git a/src/main/java/rx/internal/operators/OperatorRetryWithPredicate.java b/src/main/java/rx/internal/operators/OperatorRetryWithPredicate.java
index 20c0565db5..649f4774d9 100644
--- a/src/main/java/rx/internal/operators/OperatorRetryWithPredicate.java
+++ b/src/main/java/rx/internal/operators/OperatorRetryWithPredicate.java
@@ -33,7 +33,7 @@ public OperatorRetryWithPredicate(Func2<Integer, Throwable, Boolean> predicate)
     public Subscriber<? super Observable<T>> call(final Subscriber<? super T> child) {
         final Scheduler.Worker inner = Schedulers.trampoline().createWorker();
         child.add(inner);
-        
+
         final SerialSubscription serialSubscription = new SerialSubscription();
         // add serialSubscription so it gets unsubscribed if child is unsubscribed
         child.add(serialSubscription);
@@ -41,19 +41,19 @@ public Subscriber<? super Observable<T>> call(final Subscriber<? super T> child)
         child.setProducer(pa);
         return new SourceSubscriber<T>(child, predicate, inner, serialSubscription, pa);
     }
-    
+
     static final class SourceSubscriber<T> extends Subscriber<Observable<T>> {
         final Subscriber<? super T> child;
         final Func2<Integer, Throwable, Boolean> predicate;
         final Scheduler.Worker inner;
         final SerialSubscription serialSubscription;
         final ProducerArbiter pa;
-        
+
         final AtomicInteger attempts = new AtomicInteger();
 
-        public SourceSubscriber(Subscriber<? super T> child, 
-                final Func2<Integer, Throwable, Boolean> predicate, 
-                Scheduler.Worker inner, 
+        public SourceSubscriber(Subscriber<? super T> child,
+                final Func2<Integer, Throwable, Boolean> predicate,
+                Scheduler.Worker inner,
                 SerialSubscription serialSubscription,
                 ProducerArbiter pa) {
             this.child = child;
@@ -62,8 +62,8 @@ public SourceSubscriber(Subscriber<? super T> child,
             this.serialSubscription = serialSubscription;
             this.pa = pa;
         }
-        
-        
+
+
         @Override
         public void onCompleted() {
             // ignore as we expect a single nested Observable<T>
@@ -122,7 +122,7 @@ public void setProducer(Producer p) {
                             pa.setProducer(p);
                         }
                     };
-                    // register this Subscription (and unsubscribe previous if exists) 
+                    // register this Subscription (and unsubscribe previous if exists)
                     serialSubscription.set(subscriber);
                     o.unsafeSubscribe(subscriber);
                 }
diff --git a/src/main/java/rx/internal/operators/OperatorSampleWithObservable.java b/src/main/java/rx/internal/operators/OperatorSampleWithObservable.java
index 605ea96120..0186e0600f 100644
--- a/src/main/java/rx/internal/operators/OperatorSampleWithObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorSampleWithObservable.java
@@ -23,9 +23,9 @@
 
 /**
  * Sample with the help of another observable.
- * 
+ *
  * @see <a href="http://msdn.microsoft.com/en-us/library/hh229742.aspx">MSDN: Observable.Sample</a>
- * 
+ *
  * @param <T> the source and result value type
  * @param <U> the element type of the sampler Observable
  */
@@ -41,11 +41,11 @@ public OperatorSampleWithObservable(Observable<U> sampler) {
     @Override
     public Subscriber<? super T> call(Subscriber<? super T> child) {
         final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
-    
+
         final AtomicReference<Object> value = new AtomicReference<Object>(EMPTY_TOKEN);
-        
+
         final AtomicReference<Subscription> main = new AtomicReference<Subscription>();
-        
+
         final Subscriber<U> samplerSub = new Subscriber<U>() {
             @Override
             public void onNext(U t) {
@@ -72,7 +72,7 @@ public void onCompleted() {
                 main.get().unsubscribe();
             }
         };
-        
+
         Subscriber<T> result = new Subscriber<T>() {
             @Override
             public void onNext(T t) {
@@ -82,7 +82,7 @@ public void onNext(T t) {
             @Override
             public void onError(Throwable e) {
                 s.onError(e);
-                
+
                 samplerSub.unsubscribe();
             }
 
@@ -94,14 +94,14 @@ public void onCompleted() {
                 samplerSub.unsubscribe();
             }
         };
-        
+
         main.lazySet(result);
-        
+
         child.add(result);
         child.add(samplerSub);
-        
+
         sampler.unsafeSubscribe(samplerSub);
-        
+
         return result;
     }
 }
diff --git a/src/main/java/rx/internal/operators/OperatorSampleWithTime.java b/src/main/java/rx/internal/operators/OperatorSampleWithTime.java
index dc9de738a6..dc7f212886 100644
--- a/src/main/java/rx/internal/operators/OperatorSampleWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorSampleWithTime.java
@@ -30,7 +30,7 @@
  * Observable at a specified time interval.
  * <p>
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/sample.png" alt="">
- * 
+ *
  * @param <T> the value type
  */
 public final class OperatorSampleWithTime<T> implements Operator<T, T> {
@@ -49,7 +49,7 @@ public Subscriber<? super T> call(Subscriber<? super T> child) {
         final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
         final Worker worker = scheduler.createWorker();
         child.add(worker);
-        
+
         SamplerSubscriber<T> sampler = new SamplerSubscriber<T>(s);
         child.add(sampler);
         worker.schedulePeriodically(sampler, time, time, unit);
@@ -69,12 +69,12 @@ static final class SamplerSubscriber<T> extends Subscriber<T> implements Action0
         public SamplerSubscriber(Subscriber<? super T> subscriber) {
             this.subscriber = subscriber;
         }
-        
+
         @Override
         public void onStart() {
             request(Long.MAX_VALUE);
         }
-        
+
         @Override
         public void onNext(T t) {
             value.set(t);
diff --git a/src/main/java/rx/internal/operators/OperatorScan.java b/src/main/java/rx/internal/operators/OperatorScan.java
index e621bce68a..d3cbf8bc52 100644
--- a/src/main/java/rx/internal/operators/OperatorScan.java
+++ b/src/main/java/rx/internal/operators/OperatorScan.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -37,7 +37,7 @@
  * <p>
  * Note that when you pass a seed to {@code scan} the resulting Observable will emit that seed as its
  * first emitted item.
- * 
+ *
  * @param <R> the aggregate and output type
  * @param <T> the input value type
  */
@@ -51,7 +51,7 @@ public final class OperatorScan<R, T> implements Operator<R, T> {
     /**
      * Applies an accumulator function over an observable sequence and returns each intermediate result with the
      * specified source and accumulator.
-     * 
+     *
      * @param initialValue
      *            the initial (seed) accumulator value
      * @param accumulator
@@ -66,10 +66,10 @@ public OperatorScan(final R initialValue, Func2<R, ? super T, R> accumulator) {
             public R call() {
                 return initialValue;
             }
-            
+
         }, accumulator);
     }
-    
+
     public OperatorScan(Func0<R> initialValueFactory, Func2<R, ? super T, R> accumulator) {
         this.initialValueFactory = initialValueFactory;
         this.accumulator = accumulator;
@@ -78,7 +78,7 @@ public OperatorScan(Func0<R> initialValueFactory, Func2<R, ? super T, R> accumul
     /**
      * Applies an accumulator function over an observable sequence and returns each intermediate result with the
      * specified source and accumulator.
-     * 
+     *
      * @param accumulator
      *            an accumulator function to be invoked on each element from the sequence
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211665.aspx">Observable.Scan(TSource) Method (IObservable(TSource), Func(TSource, TSource, TSource))</a>
@@ -91,7 +91,7 @@ public OperatorScan(final Func2<R, ? super T, R> accumulator) {
     @Override
     public Subscriber<? super T> call(final Subscriber<? super R> child) {
         final R initialValue = initialValueFactory.call();
-        
+
         if (initialValue == NO_INITIAL_VALUE) {
             return new Subscriber<T>(child) {
                 boolean once;
@@ -125,9 +125,9 @@ public void onCompleted() {
                 }
             };
         }
-        
+
         final InitialProducer<R> ip = new InitialProducer<R>(initialValue, child);
-        
+
         Subscriber<T> parent = new Subscriber<T>() {
             private R value = initialValue;
 
@@ -153,22 +153,22 @@ public void onError(Throwable e) {
             public void onCompleted() {
                 ip.onCompleted();
             }
-            
+
             @Override
             public void setProducer(final Producer producer) {
                 ip.setProducer(producer);
             }
         };
-        
+
         child.add(parent);
         child.setProducer(ip);
         return parent;
     }
-    
+
     static final class InitialProducer<R> implements Producer, Observer<R> {
         final Subscriber<? super R> child;
         final Queue<Object> queue;
-        
+
         boolean emitting;
         /** Missed a terminal event. */
         boolean missed;
@@ -178,10 +178,10 @@ static final class InitialProducer<R> implements Producer, Observer<R> {
         final AtomicLong requested;
         /** The current producer. */
         volatile Producer producer;
-        
+
         volatile boolean done;
         Throwable error;
-        
+
         public InitialProducer(R initialValue, Subscriber<? super R> child) {
             this.child = child;
             Queue<Object> q;
@@ -195,13 +195,13 @@ public InitialProducer(R initialValue, Subscriber<? super R> child) {
             q.offer(NotificationLite.instance().next(initialValue));
             this.requested = new AtomicLong();
         }
-        
+
         @Override
         public void onNext(R t) {
             queue.offer(NotificationLite.instance().next(t));
             emit();
         }
-        
+
         boolean checkTerminated(boolean d, boolean empty, Subscriber<? super R> child) {
             if (child.isUnsubscribed()) {
                 return true;
@@ -219,20 +219,20 @@ boolean checkTerminated(boolean d, boolean empty, Subscriber<? super R> child) {
             }
             return false;
         }
-        
+
         @Override
         public void onError(Throwable e) {
             error = e;
             done = true;
             emit();
         }
-        
+
         @Override
         public void onCompleted() {
             done = true;
             emit();
         }
-        
+
         @Override
         public void request(long n) {
             if (n < 0L) {
@@ -257,7 +257,7 @@ public void request(long n) {
                 emit();
             }
         }
-        
+
         public void setProducer(Producer p) {
             if (p == null) {
                 throw new NullPointerException();
@@ -277,13 +277,13 @@ public void setProducer(Producer p) {
                 missedRequested = 0L;
                 producer = p;
             }
-            
+
             if (mr > 0L) {
                 p.request(mr);
             }
             emit();
         }
-        
+
         void emit() {
             synchronized (this) {
                 if (emitting) {
@@ -294,13 +294,13 @@ void emit() {
             }
             emitLoop();
         }
-        
+
         void emitLoop() {
             final Subscriber<? super R> child = this.child;
             final Queue<Object> queue = this.queue;
             final NotificationLite<R> nl = NotificationLite.instance();
             AtomicLong requested = this.requested;
-            
+
             long r = requested.get();
             for (;;) {
                 boolean d = done;
@@ -328,11 +328,11 @@ void emitLoop() {
                     }
                     e++;
                 }
-                
+
                 if (e != 0 && r != Long.MAX_VALUE) {
                     r = BackpressureUtils.produced(requested, e);
                 }
-                
+
                 synchronized (this) {
                     if (!missed) {
                         emitting = false;
diff --git a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
index 4c15c06672..15750834fc 100644
--- a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
+++ b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/operators/OperatorSerialize.java b/src/main/java/rx/internal/operators/OperatorSerialize.java
index 2ceada9b71..98dc2455b4 100644
--- a/src/main/java/rx/internal/operators/OperatorSerialize.java
+++ b/src/main/java/rx/internal/operators/OperatorSerialize.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -33,11 +33,11 @@ static final class Holder {
     public static <T> OperatorSerialize<T> instance() {
         return (OperatorSerialize<T>)Holder.INSTANCE;
     }
-    
-    OperatorSerialize() { 
+
+    OperatorSerialize() {
         // singleton
     }
-    
+
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> s) {
         return new SerializedSubscriber<T>(new Subscriber<T>(s) {
diff --git a/src/main/java/rx/internal/operators/OperatorSingle.java b/src/main/java/rx/internal/operators/OperatorSingle.java
index 942f53ab15..32c752d20d 100644
--- a/src/main/java/rx/internal/operators/OperatorSingle.java
+++ b/src/main/java/rx/internal/operators/OperatorSingle.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -36,11 +36,11 @@ public final class OperatorSingle<T> implements Operator<T, T> {
     static final class Holder {
         final static OperatorSingle<?> INSTANCE = new OperatorSingle<Object>();
     }
-    
+
     /**
-     * Returns a singleton instance of OperatorSingle (if the stream is empty or has 
+     * Returns a singleton instance of OperatorSingle (if the stream is empty or has
      * more than one element an error will be emitted) that is cast to the generic type.
-     *  
+     *
      * @param <T> the value type
      * @return a singleton instance of an Operator that will emit a single value only unless the stream has zero or more than one element in which case it will emit an error.
      */
@@ -75,12 +75,12 @@ static final class ParentSubscriber<T> extends Subscriber<T> {
         private final Subscriber<? super T> child;
         private final boolean hasDefaultValue;
         private final T defaultValue;
-        
+
         private T value;
         private boolean isNonEmpty;
         private boolean hasTooManyElements;
 
-        
+
         ParentSubscriber(Subscriber<? super T> child, boolean hasDefaultValue,
                 T defaultValue) {
             this.child = child;
@@ -127,7 +127,7 @@ public void onError(Throwable e) {
                 RxJavaHooks.onError(e);
                 return;
             }
-            
+
             child.onError(e);
         }
 
diff --git a/src/main/java/rx/internal/operators/OperatorSkip.java b/src/main/java/rx/internal/operators/OperatorSkip.java
index cdd0511075..5e7ecebd91 100644
--- a/src/main/java/rx/internal/operators/OperatorSkip.java
+++ b/src/main/java/rx/internal/operators/OperatorSkip.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/operators/OperatorSkipUntil.java b/src/main/java/rx/internal/operators/OperatorSkipUntil.java
index 5abff347db..cde5238a40 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipUntil.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipUntil.java
@@ -24,11 +24,11 @@
 /**
  * Skip elements from the source Observable until the secondary
  * observable fires an element.
- * 
+ *
  * If the secondary Observable fires no elements, the primary won't fire any elements.
- * 
+ *
  * @see <a href="http://msdn.microsoft.com/en-us/library/hh229358.aspx">MSDN: Observable.SkipUntil</a>
- * 
+ *
  * @param <T> the source and result value type
  * @param <U> element type of the signalling observable
  */
@@ -65,7 +65,7 @@ public void onCompleted() {
         };
         child.add(u);
         other.unsafeSubscribe(u);
-        
+
         return new Subscriber<T>(child) {
             @Override
             public void onNext(T t) {
diff --git a/src/main/java/rx/internal/operators/OperatorSkipWhile.java b/src/main/java/rx/internal/operators/OperatorSkipWhile.java
index c291569ea6..70c7ed75cd 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipWhile.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipWhile.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -68,11 +68,11 @@ public void onCompleted() {
             }
         };
     }
-    /** 
+    /**
      * Convert to Func2 type predicate.
      * @param <T> the input value type
      * @param predicate the single argument predicate function
-     * @return The two argument function which ignores its second parameter  
+     * @return The two argument function which ignores its second parameter
      */
     public static <T> Func2<T, Integer, Boolean> toPredicate2(final Func1<? super T, Boolean> predicate) {
         return new Func2<T, Integer, Boolean>() {
diff --git a/src/main/java/rx/internal/operators/OperatorSubscribeOn.java b/src/main/java/rx/internal/operators/OperatorSubscribeOn.java
index 70bc2fa592..9b90cbc26a 100644
--- a/src/main/java/rx/internal/operators/OperatorSubscribeOn.java
+++ b/src/main/java/rx/internal/operators/OperatorSubscribeOn.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -24,7 +24,7 @@
  * Subscribes Observers on the specified {@code Scheduler}.
  * <p>
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/subscribeOn.png" alt="">
- * 
+ *
  * @param <T> the value type of the actual source
  */
 public final class OperatorSubscribeOn<T> implements OnSubscribe<T> {
@@ -41,18 +41,18 @@ public OperatorSubscribeOn(Observable<T> source, Scheduler scheduler) {
     public void call(final Subscriber<? super T> subscriber) {
         final Worker inner = scheduler.createWorker();
         subscriber.add(inner);
-        
+
         inner.schedule(new Action0() {
             @Override
             public void call() {
                 final Thread t = Thread.currentThread();
-                
+
                 Subscriber<T> s = new Subscriber<T>(subscriber) {
                     @Override
                     public void onNext(T t) {
                         subscriber.onNext(t);
                     }
-                    
+
                     @Override
                     public void onError(Throwable e) {
                         try {
@@ -61,7 +61,7 @@ public void onError(Throwable e) {
                             inner.unsubscribe();
                         }
                     }
-                    
+
                     @Override
                     public void onCompleted() {
                         try {
@@ -70,7 +70,7 @@ public void onCompleted() {
                             inner.unsubscribe();
                         }
                     }
-                    
+
                     @Override
                     public void setProducer(final Producer p) {
                         subscriber.setProducer(new Producer() {
@@ -90,7 +90,7 @@ public void call() {
                         });
                     }
                 };
-                
+
                 source.unsafeSubscribe(s);
             }
         });
diff --git a/src/main/java/rx/internal/operators/OperatorSwitch.java b/src/main/java/rx/internal/operators/OperatorSwitch.java
index 8c8be1dbec..aa640726d4 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitch.java
+++ b/src/main/java/rx/internal/operators/OperatorSwitch.java
@@ -33,7 +33,7 @@
  * emits the items emitted by the most recently published of those Observables.
  * <p>
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/switchDo.png" alt="">
- * 
+ *
  * @param <T> the value type
  */
 public final class OperatorSwitch<T> implements Operator<T, Observable<? extends T>> {
@@ -62,7 +62,7 @@ public static <T> OperatorSwitch<T> instance(boolean delayError) {
         return (OperatorSwitch<T>)Holder.INSTANCE;
     }
 
-    OperatorSwitch(boolean delayError) { 
+    OperatorSwitch(boolean delayError) {
         this.delayError = delayError;
     }
 
@@ -83,19 +83,19 @@ static final class SwitchSubscriber<T> extends Subscriber<Observable<? extends T
         final NotificationLite<T> nl;
 
         boolean emitting;
-        
+
         boolean missed;
-        
+
         long requested;
-        
+
         Producer producer;
-        
+
         volatile boolean mainDone;
 
         Throwable error;
-        
+
         boolean innerActive;
-        
+
         static final Throwable TERMINAL_ERROR = new Throwable("Terminal error");
 
         SwitchSubscriber(Subscriber<? super T> child, boolean delayError) {
@@ -106,7 +106,7 @@ static final class SwitchSubscriber<T> extends Subscriber<Observable<? extends T
             this.queue = new SpscLinkedArrayQueue<Object>(RxRingBuffer.SIZE);
             this.nl = NotificationLite.instance();
         }
-        
+
         void init() {
             child.add(ssub);
             child.add(Subscriptions.create(new Action0() {
@@ -128,24 +128,24 @@ public void request(long n) {
                 }
             });
         }
-        
+
         void clearProducer() {
             synchronized (this) {
                 producer = null;
             }
         }
-        
+
         @Override
         public void onNext(Observable<? extends T> t) {
             long id = index.incrementAndGet();
-            
+
             Subscription s = ssub.get();
             if (s != null) {
                 s.unsubscribe();
             }
-            
+
             InnerSubscriber<T> inner;
-            
+
             synchronized (this) {
                 inner = new InnerSubscriber<T>(id, this);
 
@@ -153,14 +153,14 @@ public void onNext(Observable<? extends T> t) {
                 producer = null;
             }
             ssub.set(inner);
-            
+
             t.unsafeSubscribe(inner);
         }
 
         @Override
         public void onError(Throwable e) {
             boolean success;
-            
+
             synchronized (this) {
                 success = updateError(e);
             }
@@ -189,19 +189,19 @@ boolean updateError(Throwable next) {
             }
             return true;
         }
-        
+
         @Override
         public void onCompleted() {
             mainDone = true;
             drain();
         }
-        
+
         void emit(T value, InnerSubscriber<T> inner) {
             synchronized (this) {
                 if (index.get() != inner.id) {
                     return;
                 }
-                
+
                 queue.offer(inner, nl.next(value));
             }
             drain();
@@ -224,7 +224,7 @@ void error(Throwable e, long id) {
                 pluginError(e);
             }
         }
-        
+
         void complete(long id) {
             synchronized (this) {
                 if (index.get() != id) {
@@ -239,7 +239,7 @@ void complete(long id) {
         void pluginError(Throwable e) {
             RxJavaHooks.onError(e);
         }
-        
+
         void innerProducer(Producer p, long id) {
             long n;
             synchronized (this) {
@@ -249,10 +249,10 @@ void innerProducer(Producer p, long id) {
                 n = requested;
                 producer = p;
             }
-            
+
             p.request(n);
         }
-        
+
         void childRequested(long n) {
             Producer p;
             synchronized (this) {
@@ -264,7 +264,7 @@ void childRequested(long n) {
             }
             drain();
         }
-        
+
         void drain() {
             boolean localInnerActive;
             long localRequested;
@@ -298,52 +298,52 @@ void drain() {
                     }
 
                     boolean empty = localQueue.isEmpty();
-                    
-                    if (checkTerminated(localMainDone, localInnerActive, localError, 
+
+                    if (checkTerminated(localMainDone, localInnerActive, localError,
                             localQueue, localChild, empty)) {
                         return;
                     }
-                    
+
                     if (empty) {
                         break;
                     }
-                    
+
                     @SuppressWarnings("unchecked")
                     InnerSubscriber<T> inner = (InnerSubscriber<T>)localQueue.poll();
                     T value = nl.getValue(localQueue.poll());
-                    
+
                     if (localIndex.get() == inner.id) {
                         localChild.onNext(value);
                         localEmission++;
                     }
                 }
-                
+
                 if (localEmission == localRequested) {
                     if (localChild.isUnsubscribed()) {
                         return;
                     }
-                    
-                    if (checkTerminated(mainDone, localInnerActive, localError, localQueue, 
+
+                    if (checkTerminated(mainDone, localInnerActive, localError, localQueue,
                             localChild, localQueue.isEmpty())) {
                         return;
                     }
                 }
-                
-                
+
+
                 synchronized (this) {
-                    
+
                     localRequested = requested;
                     if (localRequested != Long.MAX_VALUE) {
                         localRequested -= localEmission;
                         requested = localRequested;
                     }
-                    
+
                     if (!missed) {
                         emitting = false;
                         return;
                     }
                     missed = false;
-                    
+
                     localMainDone = mainDone;
                     localInnerActive = innerActive;
                     localError = error;
@@ -379,7 +379,7 @@ protected boolean checkTerminated(boolean localMainDone, boolean localInnerActiv
             return false;
         }
     }
-    
+
     static final class InnerSubscriber<T> extends Subscriber<T> {
 
         private final long id;
@@ -390,7 +390,7 @@ static final class InnerSubscriber<T> extends Subscriber<T> {
             this.id = id;
             this.parent = parent;
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             parent.innerProducer(p, id);
diff --git a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java b/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
index 890f18cebf..db4fb0f5ed 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
+++ b/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
@@ -91,9 +91,9 @@ public void onNext(T t) {
             arbiter.produced(1);
         }
     }
-    
+
     static final class AlternateSubscriber<T> extends Subscriber<T> {
-        
+
         private final ProducerArbiter arbiter;
         private final Subscriber<? super T> child;
 
@@ -101,7 +101,7 @@ static final class AlternateSubscriber<T> extends Subscriber<T> {
             this.child = child;
             this.arbiter = arbiter;
         }
-        
+
         @Override
         public void setProducer(final Producer producer) {
             arbiter.setProducer(producer);
@@ -121,6 +121,6 @@ public void onError(Throwable e) {
         public void onNext(T t) {
             child.onNext(t);
             arbiter.produced(1);
-        }        
+        }
     }
 }
diff --git a/src/main/java/rx/internal/operators/OperatorTake.java b/src/main/java/rx/internal/operators/OperatorTake.java
index 51be87e178..7835327ec4 100644
--- a/src/main/java/rx/internal/operators/OperatorTake.java
+++ b/src/main/java/rx/internal/operators/OperatorTake.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -91,14 +91,14 @@ public void onNext(T i) {
             @Override
             public void setProducer(final Producer producer) {
                 child.setProducer(new Producer() {
-                    
+
                     // keeps track of requests up to maximum of `limit`
                     final AtomicLong requested = new AtomicLong(0);
-                    
+
                     @Override
                     public void request(long n) {
                         if (n >0 && !completed) {
-                            // because requests may happen concurrently use a CAS loop to 
+                            // because requests may happen concurrently use a CAS loop to
                             // ensure we only request as much as needed, no more no less
                             while (true) {
                                 long r = requested.get();
@@ -125,9 +125,9 @@ public void request(long n) {
         /*
          * We decouple the parent and child subscription so there can be multiple take() in a chain such as for
          * the groupBy Observer use case where you may take(1) on groups and take(20) on the children.
-         * 
+         *
          * Thus, we only unsubscribe UPWARDS to the parent and an onComplete DOWNSTREAM.
-         * 
+         *
          * However, if we receive an unsubscribe from the child we still want to propagate it upwards so we
          * register 'parent' with 'child'
          */
diff --git a/src/main/java/rx/internal/operators/OperatorTakeLast.java b/src/main/java/rx/internal/operators/OperatorTakeLast.java
index 77f8c93993..6767484677 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeLast.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeLast.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -26,7 +26,7 @@
  * Returns an Observable that emits the at most the last <code>count</code> items emitted by the source Observable.
  * <p>
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/last.png" alt="">
- * 
+ *
  * @param <T> the value type
  */
 public final class OperatorTakeLast<T> implements Operator<T, T> {
@@ -43,7 +43,7 @@ public OperatorTakeLast(int count) {
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
         final TakeLastSubscriber<T> parent = new TakeLastSubscriber<T>(subscriber, count);
-        
+
         subscriber.add(parent);
         subscriber.setProducer(new Producer() {
             @Override
@@ -51,17 +51,17 @@ public void request(long n) {
                 parent.requestMore(n);
             }
         });
-        
+
         return parent;
     }
-    
+
     static final class TakeLastSubscriber<T> extends Subscriber<T> implements Func1<Object, T> {
         final Subscriber<? super T> actual;
         final AtomicLong requested;
         final ArrayDeque<Object> queue;
         final int count;
         final NotificationLite<T> nl;
-        
+
         public TakeLastSubscriber(Subscriber<? super T> actual, int count) {
             this.actual = actual;
             this.count = count;
@@ -69,7 +69,7 @@ public TakeLastSubscriber(Subscriber<? super T> actual, int count) {
             this.queue = new ArrayDeque<Object>();
             this.nl = NotificationLite.instance();
         }
-        
+
         @Override
         public void onNext(T t) {
             if (queue.size() == count) {
@@ -77,23 +77,23 @@ public void onNext(T t) {
             }
             queue.offer(nl.next(t));
         }
-        
+
         @Override
         public void onError(Throwable e) {
             queue.clear();
             actual.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             BackpressureUtils.postCompleteDone(requested, queue, actual, this);
         }
-        
+
         @Override
         public T call(Object t) {
             return nl.getValue(t);
         }
-        
+
         void requestMore(long n) {
             if (n > 0L) {
                 BackpressureUtils.postCompleteRequest(requested, n, queue, actual, this);
diff --git a/src/main/java/rx/internal/operators/OperatorTakeLastTimed.java b/src/main/java/rx/internal/operators/OperatorTakeLastTimed.java
index 383f41715c..e4a35922ad 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeLastTimed.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeLastTimed.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -27,7 +27,7 @@
  * Returns an Observable that emits the last <code>count</code> items emitted by the source Observable.
  * <p>
  * <img width="640" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/last.png" alt="">
- * 
+ *
  * @param <T> the value type
  */
 public final class OperatorTakeLastTimed<T> implements Operator<T, T> {
@@ -54,7 +54,7 @@ public OperatorTakeLastTimed(int count, long time, TimeUnit unit, Scheduler sche
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
         final TakeLastTimedSubscriber<T> parent = new TakeLastTimedSubscriber<T>(subscriber, count, ageMillis, scheduler);
-        
+
         subscriber.add(parent);
         subscriber.setProducer(new Producer() {
             @Override
@@ -62,10 +62,10 @@ public void request(long n) {
                 parent.requestMore(n);
             }
         });
-        
+
         return parent;
     }
-    
+
     static final class TakeLastTimedSubscriber<T> extends Subscriber<T> implements Func1<Object, T> {
         final Subscriber<? super T> actual;
         final long ageMillis;
@@ -86,19 +86,19 @@ public TakeLastTimedSubscriber(Subscriber<? super T> actual, int count, long age
             this.queueTimes = new ArrayDeque<Long>();
             this.nl = NotificationLite.instance();
         }
-        
+
         @Override
         public void onNext(T t) {
             if (count != 0) {
                 long now = scheduler.now();
-    
+
                 if (queue.size() == count) {
                     queue.poll();
                     queueTimes.poll();
                 }
-                
+
                 evictOld(now);
-                
+
                 queue.offer(nl.next(t));
                 queueTimes.offer(now);
             }
@@ -115,28 +115,28 @@ protected void evictOld(long now) {
                 queueTimes.poll();
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             queue.clear();
             queueTimes.clear();
             actual.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             evictOld(scheduler.now());
-            
+
             queueTimes.clear();
-            
+
             BackpressureUtils.postCompleteDone(requested, queue, actual, this);
         }
-        
+
         @Override
         public T call(Object t) {
             return nl.getValue(t);
         }
-        
+
         void requestMore(long n) {
             BackpressureUtils.postCompleteRequest(requested, n, queue, actual, this);
         }
diff --git a/src/main/java/rx/internal/operators/OperatorTakeTimed.java b/src/main/java/rx/internal/operators/OperatorTakeTimed.java
index 91bd05c5ab..1b1aa0726c 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeTimed.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeTimed.java
@@ -25,7 +25,7 @@
 
 /**
  * Takes values from the source until the specific time elapses.
- * 
+ *
  * @param <T>
  *            the result value type
  */
@@ -44,7 +44,7 @@ public OperatorTakeTimed(long time, TimeUnit unit, Scheduler scheduler) {
     public Subscriber<? super T> call(Subscriber<? super T> child) {
         Worker worker = scheduler.createWorker();
         child.add(worker);
-        
+
         TakeSubscriber<T> ts = new TakeSubscriber<T>(new SerializedSubscriber<T>(child));
         worker.schedule(ts, time, unit);
         return ts;
@@ -78,7 +78,7 @@ public void onCompleted() {
         public void call() {
             onCompleted();
         }
-        
-        
+
+
     }
 }
diff --git a/src/main/java/rx/internal/operators/OperatorTakeUntil.java b/src/main/java/rx/internal/operators/OperatorTakeUntil.java
index 56778a866c..3981855730 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeUntil.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeUntil.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -38,7 +38,7 @@ public OperatorTakeUntil(final Observable<? extends E> other) {
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         final Subscriber<T> serial = new SerializedSubscriber<T>(child, false);
-        
+
         final Subscriber<T> main = new Subscriber<T>(serial, false) {
             @Override
             public void onNext(T t) {
@@ -61,13 +61,13 @@ public void onCompleted() {
                 }
             }
         };
-        
+
         final Subscriber<E> so = new Subscriber<E>() {
             @Override
             public void onStart() {
                 request(Long.MAX_VALUE);
             }
-            
+
             @Override
             public void onCompleted() {
                 main.onCompleted();
@@ -87,9 +87,9 @@ public void onNext(E t) {
 
         serial.add(main);
         serial.add(so);
-        
+
         child.add(serial);
-        
+
         other.unsafeSubscribe(so);
 
         return main;
diff --git a/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java b/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
index 0b19f2e051..63d4c86407 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -43,7 +43,7 @@ public void request(long n) {
                 parent.downstreamRequest(n);
             }
         });
-        
+
         return parent;
     }
 
@@ -59,7 +59,7 @@ final class ParentSubscriber extends Subscriber<T> {
         @Override
         public void onNext(T t) {
             child.onNext(t);
-            
+
             boolean stop = false;
             try {
                 stop = stopPredicate.call(t);
diff --git a/src/main/java/rx/internal/operators/OperatorTakeWhile.java b/src/main/java/rx/internal/operators/OperatorTakeWhile.java
index c444627819..9ee2147f2d 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeWhile.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeWhile.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/operators/OperatorThrottleFirst.java b/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
index d41f3262eb..fbd3c64d7d 100644
--- a/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
+++ b/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -44,14 +44,14 @@ public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
             public void onStart() {
                 request(Long.MAX_VALUE);
             }
-            
+
             @Override
             public void onNext(T v) {
                 long now = scheduler.now();
                 if (lastOnNext == -1 || now - lastOnNext >= timeInMilliseconds) {
                     lastOnNext = now;
                     subscriber.onNext(v);
-                } 
+                }
             }
 
             @Override
diff --git a/src/main/java/rx/internal/operators/OperatorTimeInterval.java b/src/main/java/rx/internal/operators/OperatorTimeInterval.java
index 17f370e721..3900bc27aa 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeInterval.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeInterval.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/operators/OperatorTimeout.java b/src/main/java/rx/internal/operators/OperatorTimeout.java
index e7d13d32ad..3c74663e80 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeout.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeout.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/operators/OperatorTimeoutBase.java b/src/main/java/rx/internal/operators/OperatorTimeoutBase.java
index d2fcc2a0ef..435a60e503 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeoutBase.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeoutBase.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -32,7 +32,7 @@ class OperatorTimeoutBase<T> implements Operator<T, T> {
 
     /**
      * Set up the timeout action on the first value.
-     * 
+     *
      * @param <T>
      */
     /* package-private */interface FirstTimeoutStub<T> extends
@@ -41,7 +41,7 @@ class OperatorTimeoutBase<T> implements Operator<T, T> {
 
     /**
      * Set up the timeout action based on every value
-     * 
+     *
      * @param <T>
      */
     /* package-private */interface TimeoutStub<T> extends
@@ -68,12 +68,12 @@ public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
         synchronizedSubscriber.add(serial);
 
         TimeoutSubscriber<T> timeoutSubscriber = new TimeoutSubscriber<T>(synchronizedSubscriber, timeoutStub, serial, other, inner);
-        
+
         synchronizedSubscriber.add(timeoutSubscriber);
         synchronizedSubscriber.setProducer(timeoutSubscriber.arbiter);
-        
+
         serial.set(firstTimeoutStub.call(timeoutSubscriber, 0L, inner));
-        
+
         return timeoutSubscriber;
     }
 
@@ -87,16 +87,16 @@ public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
         final TimeoutStub<T> timeoutStub;
 
         final Observable<? extends T> other;
-        
+
         final Scheduler.Worker inner;
-        
+
         final ProducerArbiter arbiter;
-        
+
         /** Guarded by this. */
         boolean terminated;
         /** Guarded by this. */
         long actual;
-        
+
         TimeoutSubscriber(
                 SerializedSubscriber<T> serializedSubscriber,
                 TimeoutStub<T> timeoutStub, SerialSubscription serial,
@@ -114,7 +114,7 @@ public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
         public void setProducer(Producer p) {
             arbiter.setProducer(p);
         }
-        
+
         @Override
         public void onNext(T value) {
             boolean onNextWins = false;
@@ -181,17 +181,17 @@ public void onTimeout(long seqId) {
                         public void onNext(T t) {
                             serializedSubscriber.onNext(t);
                         }
-                        
+
                         @Override
                         public void onError(Throwable e) {
                             serializedSubscriber.onError(e);
                         }
-                        
+
                         @Override
                         public void onCompleted() {
                             serializedSubscriber.onCompleted();
                         }
-                        
+
                         @Override
                         public void setProducer(Producer p) {
                             arbiter.setProducer(p);
diff --git a/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java b/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
index 9497b1188f..d455ba62e4 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/operators/OperatorTimestamp.java b/src/main/java/rx/internal/operators/OperatorTimestamp.java
index 9068f5d088..6e6c693a06 100644
--- a/src/main/java/rx/internal/operators/OperatorTimestamp.java
+++ b/src/main/java/rx/internal/operators/OperatorTimestamp.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/operators/OperatorToObservableList.java b/src/main/java/rx/internal/operators/OperatorToObservableList.java
index 670a83ce7a..2d2ffaa99c 100644
--- a/src/main/java/rx/internal/operators/OperatorToObservableList.java
+++ b/src/main/java/rx/internal/operators/OperatorToObservableList.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -51,10 +51,10 @@ static final class Holder {
     public static <T> OperatorToObservableList<T> instance() {
         return (OperatorToObservableList<T>)Holder.INSTANCE;
     }
-    OperatorToObservableList() { 
+    OperatorToObservableList() {
         // singleton
     }
-    
+
     @Override
     public Subscriber<? super T> call(final Subscriber<? super List<T>> o) {
         final SingleDelayedProducer<List<T>> producer = new SingleDelayedProducer<List<T>>(o);
@@ -75,11 +75,11 @@ public void onCompleted() {
                     List<T> result;
                     try {
                         /*
-                         * Ideally this should just return Collections.unmodifiableList(list) and not copy it, 
-                         * but, it ends up being a breaking change if we make that modification. 
-                         * 
+                         * Ideally this should just return Collections.unmodifiableList(list) and not copy it,
+                         * but, it ends up being a breaking change if we make that modification.
+                         *
                          * Here is an example of is being done with these lists that breaks if we make it immutable:
-                         * 
+                         *
                          * Caused by: java.lang.UnsupportedOperationException
                          *     at java.util.Collections$UnmodifiableList$1.set(Collections.java:1244)
                          *     at java.util.Collections.sort(Collections.java:221)
diff --git a/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java b/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java
index 3de4f14e21..ab14cf02a4 100644
--- a/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java
+++ b/src/main/java/rx/internal/operators/OperatorToObservableSortedList.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -29,7 +29,7 @@
  * items in the sequence, or you must pass in a sort function).
  * <p>
  * <img width="640" height="310" src="https://raw.githubusercontent.com/wiki/ReactiveX/RxJava/images/rx-operators/toSortedList.png" alt="">
- * 
+ *
  * @param <T>
  *          the type of the items emitted by the source and the resulting {@code Observable}s
  */
@@ -63,7 +63,7 @@ public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
 
             List<T> list = new ArrayList<T>(initialCapacity);
             boolean completed;
-            
+
             @Override
             public void onStart() {
                 request(Long.MAX_VALUE);
diff --git a/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java b/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
index 21c424457c..2f72d62d6b 100644
--- a/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
+++ b/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -53,7 +53,7 @@ public void onNext(T t) {
             }
 
         };
-        
+
         subscriber.add(Subscriptions.create(new Action0() {
 
             @Override
@@ -70,7 +70,7 @@ public void call() {
             }
 
         }));
-        
+
         return parent;
 
 
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java b/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
index c5a56e9b6d..4849f162d8 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
@@ -27,7 +27,7 @@
 /**
  * Creates non-overlapping windows of items where each window is terminated by
  * an event from a secondary observable and a new window is started immediately.
- * 
+ *
  * @param <T> the value type
  * @param <U> the boundary value type
  */
@@ -41,20 +41,20 @@ public final class OperatorWindowWithObservable<T, U> implements Operator<Observ
     public OperatorWindowWithObservable(final Observable<U> other) {
         this.other = other;
     }
-    
+
     @Override
     public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
-        
+
         SourceSubscriber<T> sub = new SourceSubscriber<T>(child);
         BoundarySubscriber<T, U> bs = new BoundarySubscriber<T, U>(sub);
-        
+
         child.add(sub);
         child.add(bs);
-        
+
         sub.replaceWindow();
-        
+
         other.unsafeSubscribe(bs);
-        
+
         return sub;
     }
     /** Observes the source. */
@@ -69,17 +69,17 @@ static final class SourceSubscriber<T> extends Subscriber<T> {
         boolean emitting;
         /** Guarded by guard. */
         List<Object> queue;
-        
+
         public SourceSubscriber(Subscriber<? super Observable<T>> child) {
             this.child = new SerializedSubscriber<Observable<T>>(child);
             this.guard = new Object();
         }
-        
+
         @Override
         public void onStart() {
             request(Long.MAX_VALUE);
         }
-        
+
         @Override
         public void onNext(T t) {
             List<Object> localQueue;
@@ -104,7 +104,7 @@ public void onNext(T t) {
                         once = false;
                         emitValue(t);
                     }
-                    
+
                     synchronized (guard) {
                         localQueue = queue;
                         queue = null;
@@ -165,7 +165,7 @@ void emitValue(T t) {
                 s.onNext(t);
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             synchronized (guard) {
@@ -247,7 +247,7 @@ void complete() {
             Observer<T> s = consumer;
             consumer = null;
             producer = null;
-            
+
             if (s != null) {
                 s.onCompleted();
             }
@@ -258,7 +258,7 @@ void error(Throwable e) {
             Observer<T> s = consumer;
             consumer = null;
             producer = null;
-            
+
             if (s != null) {
                 s.onError(e);
             }
@@ -272,12 +272,12 @@ static final class BoundarySubscriber<T, U> extends Subscriber<U> {
         public BoundarySubscriber(SourceSubscriber<T> sub) {
             this.sub = sub;
         }
-        
+
         @Override
         public void onStart() {
             request(Long.MAX_VALUE);
         }
-        
+
         @Override
         public void onNext(U t) {
             sub.replaceWindow();
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
index 6cbc4264d2..6873526940 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
@@ -29,7 +29,7 @@
 /**
  * Creates non-overlapping windows of items where each window is terminated by
  * an event from a secondary observable and a new window is started immediately.
- * 
+ *
  * @param <T> the value type
  * @param <U> the boundary value type
  */
@@ -44,16 +44,16 @@ public final class OperatorWindowWithObservableFactory<T, U> implements Operator
     public OperatorWindowWithObservableFactory(Func0<? extends Observable<? extends U>> otherFactory) {
         this.otherFactory = otherFactory;
     }
-    
+
     @Override
     public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
-        
+
         SourceSubscriber<T, U> sub = new SourceSubscriber<T, U>(child, otherFactory);
-        
+
         child.add(sub);
-        
+
         sub.replaceWindow();
-        
+
         return sub;
     }
     /** Observes the source. */
@@ -68,12 +68,12 @@ static final class SourceSubscriber<T, U> extends Subscriber<T> {
         boolean emitting;
         /** Guarded by guard. */
         List<Object> queue;
-        
+
         final SerialSubscription ssub;
-        
+
         final Func0<? extends Observable<? extends U>> otherFactory;
-        
-        public SourceSubscriber(Subscriber<? super Observable<T>> child, 
+
+        public SourceSubscriber(Subscriber<? super Observable<T>> child,
                 Func0<? extends Observable<? extends U>> otherFactory) {
             this.child = new SerializedSubscriber<Observable<T>>(child);
             this.guard = new Object();
@@ -81,12 +81,12 @@ public SourceSubscriber(Subscriber<? super Observable<T>> child,
             this.otherFactory = otherFactory;
             this.add(ssub);
         }
-        
+
         @Override
         public void onStart() {
             request(Long.MAX_VALUE);
         }
-        
+
         @Override
         public void onNext(T t) {
             List<Object> localQueue;
@@ -111,7 +111,7 @@ public void onNext(T t) {
                         once = false;
                         emitValue(t);
                     }
-                    
+
                     synchronized (guard) {
                         localQueue = queue;
                         queue = null;
@@ -173,7 +173,7 @@ void createNewWindow() {
                 unsubscribe();
                 return;
             }
-            
+
             BoundarySubscriber<T, U> bs = new BoundarySubscriber<T, U>(this);
             ssub.set(bs);
             other.unsafeSubscribe(bs);
@@ -184,7 +184,7 @@ void emitValue(T t) {
                 s.onNext(t);
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             synchronized (guard) {
@@ -266,7 +266,7 @@ void complete() {
             Observer<T> s = consumer;
             consumer = null;
             producer = null;
-            
+
             if (s != null) {
                 s.onCompleted();
             }
@@ -277,7 +277,7 @@ void error(Throwable e) {
             Observer<T> s = consumer;
             consumer = null;
             producer = null;
-            
+
             if (s != null) {
                 s.onError(e);
             }
@@ -292,12 +292,12 @@ static final class BoundarySubscriber<T, U> extends Subscriber<U> {
         public BoundarySubscriber(SourceSubscriber<T, U> sub) {
             this.sub = sub;
         }
-        
+
         @Override
         public void onStart() {
             request(Long.MAX_VALUE);
         }
-        
+
         @Override
         public void onNext(U t) {
             if (!done) {
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithSize.java b/src/main/java/rx/internal/operators/OperatorWindowWithSize.java
index 4873a3109b..155d428426 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithSize.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithSize.java
@@ -28,14 +28,14 @@
 
 /**
  * Creates windows of values into the source sequence with skip frequency and size bounds.
- * 
+ *
  * If skip == size then the windows are non-overlapping, otherwise, windows may overlap
  * or can be discontinuous. The returned Observable sequence is cold and need to be
  * consumed while the window operation is in progress.
- * 
+ *
  * <p>Note that this conforms the Rx.NET behavior, but does not match former RxJava
  * behavior, which operated as a regular buffer and mapped its lists to Observables.</p>
- * 
+ *
  * @param <T> the value type
  */
 public final class OperatorWindowWithSize<T> implements Operator<Observable<T>, T> {
@@ -51,43 +51,43 @@ public OperatorWindowWithSize(int size, int skip) {
     public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
         if (skip == size) {
             WindowExact<T> parent = new WindowExact<T>(child, size);
-            
+
             child.add(parent.cancel);
             child.setProducer(parent.createProducer());
-            
+
             return parent;
         } else
         if (skip > size) {
             WindowSkip<T> parent = new WindowSkip<T>(child, size, skip);
-            
+
             child.add(parent.cancel);
             child.setProducer(parent.createProducer());
-            
+
             return parent;
         }
 
         WindowOverlap<T> parent = new WindowOverlap<T>(child, size, skip);
-        
+
         child.add(parent.cancel);
         child.setProducer(parent.createProducer());
-        
+
         return parent;
-        
+
     }
-    
+
     static final class WindowExact<T> extends Subscriber<T> implements Action0 {
         final Subscriber<? super Observable<T>> actual;
-        
+
         final int size;
-        
+
         final AtomicInteger wip;
-        
+
         final Subscription cancel;
-        
+
         int index;
-        
+
         Subject<T, T> window;
-        
+
         public WindowExact(Subscriber<? super Observable<T>> actual, int size) {
             this.actual = actual;
             this.size = size;
@@ -96,24 +96,24 @@ public WindowExact(Subscriber<? super Observable<T>> actual, int size) {
             this.add(cancel);
             this.request(0);
         }
-        
+
         @Override
         public void onNext(T t) {
             int i = index;
-            
+
             Subject<T, T> w = window;
             if (i == 0) {
                 wip.getAndIncrement();
-                
+
                 w = UnicastSubject.create(size, this);
                 window = w;
-                
+
                 actual.onNext(w);
             }
             i++;
-            
+
             w.onNext(t);
-            
+
             if (i == size) {
                 index = 0;
                 window = null;
@@ -122,29 +122,29 @@ public void onNext(T t) {
                 index = i;
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             Subject<T, T> w = window;
-            
+
             if (w != null) {
                 window = null;
                 w.onError(e);
             }
             actual.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             Subject<T, T> w = window;
-            
+
             if (w != null) {
                 window = null;
                 w.onCompleted();
             }
             actual.onCompleted();
         }
-        
+
         Producer createProducer() {
             return new Producer() {
                 @Override
@@ -159,7 +159,7 @@ public void request(long n) {
                 }
             };
         }
-        
+
         @Override
         public void call() {
             if (wip.decrementAndGet() == 0) {
@@ -167,22 +167,22 @@ public void call() {
             }
         }
     }
-    
+
     static final class WindowSkip<T> extends Subscriber<T> implements Action0 {
         final Subscriber<? super Observable<T>> actual;
-        
+
         final int size;
-        
+
         final int skip;
-        
+
         final AtomicInteger wip;
-        
+
         final Subscription cancel;
-        
+
         int index;
-        
+
         Subject<T, T> window;
-        
+
         public WindowSkip(Subscriber<? super Observable<T>> actual, int size, int skip) {
             this.actual = actual;
             this.size = size;
@@ -192,26 +192,26 @@ public WindowSkip(Subscriber<? super Observable<T>> actual, int size, int skip)
             this.add(cancel);
             this.request(0);
         }
-        
+
         @Override
         public void onNext(T t) {
             int i = index;
-            
+
             Subject<T, T> w = window;
             if (i == 0) {
                 wip.getAndIncrement();
-                
+
                 w = UnicastSubject.create(size, this);
                 window = w;
-                
+
                 actual.onNext(w);
             }
             i++;
-            
+
             if (w != null) {
                 w.onNext(t);
             }
-            
+
             if (i == size) {
                 index = i;
                 window = null;
@@ -222,42 +222,42 @@ public void onNext(T t) {
             } else {
                 index = i;
             }
-            
+
         }
-        
+
         @Override
         public void onError(Throwable e) {
             Subject<T, T> w = window;
-            
+
             if (w != null) {
                 window = null;
                 w.onError(e);
             }
             actual.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             Subject<T, T> w = window;
-            
+
             if (w != null) {
                 window = null;
                 w.onCompleted();
             }
             actual.onCompleted();
         }
-        
+
         Producer createProducer() {
             return new WindowSkipProducer();
         }
-        
+
         @Override
         public void call() {
             if (wip.decrementAndGet() == 0) {
                 unsubscribe();
             }
         }
-        
+
         final class WindowSkipProducer extends AtomicBoolean implements Producer {
             /** */
             private static final long serialVersionUID = 4625807964358024108L;
@@ -282,34 +282,34 @@ public void request(long n) {
             }
         }
     }
-    
+
     static final class WindowOverlap<T> extends Subscriber<T> implements Action0 {
         final Subscriber<? super Observable<T>> actual;
-        
+
         final int size;
-        
+
         final int skip;
-        
+
         final AtomicInteger wip;
-        
+
         final Subscription cancel;
 
         final ArrayDeque<Subject<T, T>> windows;
 
         final AtomicLong requested;
-        
+
         final AtomicInteger drainWip;
-        
+
         final Queue<Subject<T, T>> queue;
-        
+
         Throwable error;
-        
+
         volatile boolean done;
-        
+
         int index;
-        
+
         int produced;
-        
+
         public WindowOverlap(Subscriber<? super Observable<T>> actual, int size, int skip) {
             this.actual = actual;
             this.size = size;
@@ -324,19 +324,19 @@ public WindowOverlap(Subscriber<? super Observable<T>> actual, int size, int ski
             int maxWindows = (size + (skip - 1)) / skip;
             this.queue = new SpscLinkedArrayQueue<Subject<T, T>>(maxWindows);
         }
-        
+
         @Override
         public void onNext(T t) {
             int i = index;
-            
+
             ArrayDeque<Subject<T, T>> q = windows;
-            
+
             if (i == 0 && !actual.isUnsubscribed()) {
                 wip.getAndIncrement();
-                
+
                 Subject<T, T> w = UnicastSubject.create(16, this);
                 q.offer(w);
-                
+
                 queue.offer(w);
                 drain();
             }
@@ -346,10 +346,10 @@ public void onNext(T t) {
             }
 
             int p = produced + 1;
-            
+
             if (p == size) {
                 produced = p - skip;
-                
+
                 Subject<T, T> w = q.poll();
                 if (w != null) {
                     w.onCompleted();
@@ -357,7 +357,7 @@ public void onNext(T t) {
             } else {
                 produced = p;
             }
-            
+
             i++;
             if (i == skip) {
                 index = 0;
@@ -365,41 +365,41 @@ public void onNext(T t) {
                 index = i;
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             for (Subject<T, T> w : windows) {
                 w.onError(e);
             }
             windows.clear();
-            
+
             error = e;
             done = true;
             drain();
         }
-        
+
         @Override
         public void onCompleted() {
             for (Subject<T, T> w : windows) {
                 w.onCompleted();
             }
             windows.clear();
-            
+
             done = true;
             drain();
         }
-        
+
         Producer createProducer() {
             return new WindowOverlapProducer();
         }
-        
+
         @Override
         public void call() {
             if (wip.decrementAndGet() == 0) {
                 unsubscribe();
             }
         }
-        
+
         void drain() {
             AtomicInteger dw = drainWip;
             if (dw.getAndIncrement() != 0) {
@@ -408,49 +408,49 @@ void drain() {
 
             final Subscriber<? super Subject<T, T>> a = actual;
             final Queue<Subject<T, T>> q = queue;
-            
+
             int missed = 1;
-            
+
             for (;;) {
-                
+
                 long r = requested.get();
                 long e = 0L;
-                
+
                 while (e != r) {
                     boolean d = done;
                     Subject<T, T> v = q.poll();
                     boolean empty = v == null;
-                    
+
                     if (checkTerminated(d, empty, a, q)) {
                         return;
                     }
-                    
+
                     if (empty) {
                         break;
                     }
-                    
+
                     a.onNext(v);
-                    
+
                     e++;
                 }
-                
+
                 if (e == r) {
                     if (checkTerminated(done, q.isEmpty(), a, q)) {
                         return;
                     }
                 }
-                
+
                 if (e != 0 && r != Long.MAX_VALUE) {
                     requested.addAndGet(-e);
                 }
-                
+
                 missed = dw.addAndGet(-missed);
                 if (missed == 0) {
                     break;
                 }
             }
         }
-        
+
         boolean checkTerminated(boolean d, boolean empty, Subscriber<? super Subject<T, T>> a, Queue<Subject<T, T>> q) {
             if (a.isUnsubscribed()) {
                 q.clear();
@@ -470,7 +470,7 @@ boolean checkTerminated(boolean d, boolean empty, Subscriber<? super Subject<T,
             }
             return false;
         }
-        
+
         final class WindowOverlapProducer extends AtomicBoolean implements Producer {
             /** */
             private static final long serialVersionUID = 4625807964358024108L;
@@ -481,19 +481,19 @@ public void request(long n) {
                     throw new IllegalArgumentException("n >= 0 required but it was " + n);
                 }
                 if (n != 0L) {
-                    
+
                     WindowOverlap<T> parent = WindowOverlap.this;
-                    
+
                     if (!get() && compareAndSet(false, true)) {
                         long u = BackpressureUtils.multiplyCap(parent.skip, n - 1);
                         long v = BackpressureUtils.addCap(u, parent.size);
-                        
+
                         parent.request(v);
                     } else {
                         long u = BackpressureUtils.multiplyCap(parent.skip, n);
                         WindowOverlap.this.request(u);
                     }
-                    
+
                     BackpressureUtils.getAndAddRequest(parent.requested, n);
                     parent.drain();
                 }
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java b/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
index 5b28564bc0..bb7eb094d7 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
@@ -28,9 +28,9 @@
 
 /**
  * Creates potentially overlapping windows of the source items where each window is
- * started by a value emitted by an observable and closed when an associated Observable emits 
+ * started by a value emitted by an observable and closed when an associated Observable emits
  * a value or completes.
- * 
+ *
  * @param <T> the value type
  * @param <U> the type of the window opening event
  * @param <V> the type of the window closing event
@@ -39,26 +39,26 @@ public final class OperatorWindowWithStartEndObservable<T, U, V> implements Oper
     final Observable<? extends U> windowOpenings;
     final Func1<? super U, ? extends Observable<? extends V>> windowClosingSelector;
 
-    public OperatorWindowWithStartEndObservable(Observable<? extends U> windowOpenings, 
+    public OperatorWindowWithStartEndObservable(Observable<? extends U> windowOpenings,
             Func1<? super U, ? extends Observable<? extends V>> windowClosingSelector) {
         this.windowOpenings = windowOpenings;
         this.windowClosingSelector = windowClosingSelector;
     }
-    
+
     @Override
     public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
         CompositeSubscription csub = new CompositeSubscription();
         child.add(csub);
-        
+
         final SourceSubscriber sub = new SourceSubscriber(child, csub);
-        
+
         Subscriber<U> open = new Subscriber<U>() {
 
             @Override
             public void onStart() {
                 request(Long.MAX_VALUE);
             }
-            
+
             @Override
             public void onNext(U t) {
                 sub.beginWindow(t);
@@ -74,12 +74,12 @@ public void onCompleted() {
                 sub.onCompleted();
             }
         };
-        
+
         csub.add(sub);
         csub.add(open);
-        
+
         windowOpenings.unsafeSubscribe(open);
-        
+
         return sub;
     }
     /** Serialized access to the subject. */
@@ -91,7 +91,7 @@ public SerializedSubject(Observer<T> consumer, Observable<T> producer) {
             this.consumer = new SerializedObserver<T>(consumer);
             this.producer = producer;
         }
-        
+
     }
     final class SourceSubscriber extends Subscriber<T> {
         final Subscriber<? super Observable<T>> child;
@@ -107,12 +107,12 @@ public SourceSubscriber(Subscriber<? super Observable<T>> child, CompositeSubscr
             this.chunks = new LinkedList<SerializedSubject<T>>();
             this.csub = csub;
         }
-        
+
         @Override
         public void onStart() {
             request(Long.MAX_VALUE);
         }
-        
+
         @Override
         public void onNext(T t) {
             List<SerializedSubject<T>> list;
@@ -168,7 +168,7 @@ public void onCompleted() {
                 csub.unsubscribe();
             }
         }
-        
+
         void beginWindow(U token) {
             final SerializedSubject<T> s = createSerializedSubject();
             synchronized (guard) {
@@ -178,7 +178,7 @@ void beginWindow(U token) {
                 chunks.add(s);
             }
             child.onNext(s.producer);
-            
+
             Observable<? extends V> end;
             try {
                 end = windowClosingSelector.call(token);
@@ -186,7 +186,7 @@ void beginWindow(U token) {
                 onError(e);
                 return;
             }
-            
+
             Subscriber<V> v = new Subscriber<V>() {
                 boolean once = true;
                 @Override
@@ -207,10 +207,10 @@ public void onCompleted() {
                         csub.remove(this);
                     }
                 }
-                
+
             };
             csub.add(v);
-            
+
             end.unsafeSubscribe(v);
         }
         void endWindow(SerializedSubject<T> window) {
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithTime.java b/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
index ad7b459dc2..17044bb5fe 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
@@ -50,8 +50,8 @@ public final class OperatorWindowWithTime<T> implements Operator<Observable<T>,
     static final Object NEXT_SUBJECT = new Object();
     /** For error and completion indication. */
     static final NotificationLite<Object> NL = NotificationLite.instance();
-    
-    
+
+
     public OperatorWindowWithTime(long timespan, long timeshift, TimeUnit unit, int size, Scheduler scheduler) {
         this.timespan = timespan;
         this.timeshift = timeshift;
@@ -59,19 +59,19 @@ public OperatorWindowWithTime(long timespan, long timeshift, TimeUnit unit, int
         this.size = size;
         this.scheduler = scheduler;
     }
-    
-    
+
+
     @Override
     public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
         Worker worker = scheduler.createWorker();
-        
+
         if (timespan == timeshift) {
             ExactSubscriber s = new ExactSubscriber(child, worker);
             s.add(worker);
             s.scheduleExact();
             return s;
         }
-        
+
         InexactSubscriber s = new InexactSubscriber(child, worker);
         s.add(worker);
         s.startNewChunk();
@@ -84,7 +84,7 @@ static final class State<T> {
         final Observable<T> producer;
         final int count;
         static final State<Object> EMPTY = new State<Object>(null, null, 0);
-        
+
         public State(Observer<T> consumer, Observable<T> producer, int count) {
             this.consumer = consumer;
             this.producer = producer;
@@ -114,7 +114,7 @@ final class ExactSubscriber extends Subscriber<T> {
         /** Guarded by guard. */
         boolean emitting;
         volatile State<T> state;
-        
+
         public ExactSubscriber(Subscriber<? super Observable<T>> child, Worker worker) {
             this.child = new SerializedSubscriber<Observable<T>>(child);
             this.worker = worker;
@@ -130,12 +130,12 @@ public void call() {
                 }
             }));
         }
-        
+
         @Override
         public void onStart() {
             request(Long.MAX_VALUE);
         }
-        
+
         @Override
         public void onNext(T t) {
             synchronized (guard) {
@@ -238,7 +238,7 @@ boolean emitValue(T t) {
             state = s;
             return true;
         }
-        
+
         @Override
         public void onError(Throwable e) {
             synchronized (guard) {
@@ -293,15 +293,15 @@ public void onCompleted() {
             }
             complete();
         }
-        
+
         void scheduleExact() {
             worker.schedulePeriodically(new Action0() {
-                
+
                 @Override
                 public void call() {
                     nextWindow();
                 }
-                
+
             }, 0, timespan, unit);
         }
         void nextWindow() {
@@ -331,7 +331,7 @@ void nextWindow() {
                         }
                         queue = null;
                     }
-                    
+
                     if (!drain(localQueue)) {
                         return;
                     }
@@ -345,8 +345,8 @@ void nextWindow() {
             }
         }
     }
-    /** 
-     * Record to store the subject and the emission count. 
+    /**
+     * Record to store the subject and the emission count.
      * @param <T> the subject's in-out type
      */
     static final class CountedSerializedSubject<T> {
@@ -380,7 +380,7 @@ public InexactSubscriber(Subscriber<? super Observable<T>> child, Worker worker)
         public void onStart() {
             request(Long.MAX_VALUE);
         }
-        
+
         @Override
         public void onNext(T t) {
             List<CountedSerializedSubject<T>> list;
@@ -445,7 +445,7 @@ void scheduleChunk() {
                 public void call() {
                     startNewChunk();
                 }
-                
+
             }, timeshift, timeshift, unit);
         }
         void startNewChunk() {
@@ -462,14 +462,14 @@ void startNewChunk() {
                 onError(e);
                 return;
             }
-            
+
             worker.schedule(new Action0() {
 
                 @Override
                 public void call() {
                     terminateChunk(chunk);
                 }
-                
+
             }, timespan, unit);
         }
         void terminateChunk(CountedSerializedSubject<T> chunk) {
diff --git a/src/main/java/rx/internal/operators/OperatorWithLatestFrom.java b/src/main/java/rx/internal/operators/OperatorWithLatestFrom.java
index 67b22fb982..c136e1a75e 100644
--- a/src/main/java/rx/internal/operators/OperatorWithLatestFrom.java
+++ b/src/main/java/rx/internal/operators/OperatorWithLatestFrom.java
@@ -34,7 +34,7 @@ public final class OperatorWithLatestFrom<T, U, R> implements Operator<R, T>  {
     final Observable<? extends U> other;
     /** Indicates the other has not yet emitted a value. */
     static final Object EMPTY = new Object();
-    
+
     public OperatorWithLatestFrom(Observable<? extends U> other, Func2<? super T, ? super U, ? extends R> resultSelector) {
         this.other = other;
         this.resultSelector = resultSelector;
@@ -44,9 +44,9 @@ public Subscriber<? super T> call(Subscriber<? super R> child) {
         // onError and onCompleted may happen either from the main or from other.
         final SerializedSubscriber<R> s = new SerializedSubscriber<R>(child, false);
         child.add(s);
-        
+
         final AtomicReference<Object> current = new AtomicReference<Object>(EMPTY);
-        
+
         final Subscriber<T> subscriber = new Subscriber<T>(s, true) {
             @Override
             public void onNext(T t) {
@@ -56,7 +56,7 @@ public void onNext(T t) {
                         @SuppressWarnings("unchecked")
                         U u = (U)o;
                         R result = resultSelector.call(t, u);
-                        
+
                         s.onNext(result);
                     } catch (Throwable e) {
                         Exceptions.throwOrReport(e, this);
@@ -74,7 +74,7 @@ public void onCompleted() {
                 s.unsubscribe();
             }
         };
-        
+
         Subscriber<U> otherSubscriber = new Subscriber<U>() {
             @Override
             public void onNext(U t) {
@@ -95,9 +95,9 @@ public void onCompleted() {
         };
         s.add(subscriber);
         s.add(otherSubscriber);
-        
+
         other.unsafeSubscribe(otherSubscriber);
-        
+
         return subscriber;
     }
 }
diff --git a/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java b/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java
index b4a39bc642..425cfcc4d5 100644
--- a/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java
+++ b/src/main/java/rx/internal/operators/OperatorWithLatestFromMany.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -27,13 +27,13 @@
 
 public final class OperatorWithLatestFromMany<T, R> implements OnSubscribe<R> {
     final Observable<T> main;
-    
+
     final Observable<?>[] others;
-    
+
     final Iterable<Observable<?>> othersIterable;
-    
+
     final FuncN<R> combiner;
-    
+
     public OperatorWithLatestFromMany(Observable<T> main, Observable<?>[] others, Iterable<Observable<?>> othersIterable, FuncN<R> combiner) {
         this.main = main;
         this.others = others;
@@ -44,11 +44,11 @@ public OperatorWithLatestFromMany(Observable<T> main, Observable<?>[] others, It
     @Override
     public void call(Subscriber<? super R> t) {
         SerializedSubscriber<R> serial = new SerializedSubscriber<R>(t);
-        
-        
+
+
         Observable<?>[] sources;
         int n = 0;
-        
+
         if (others != null) {
             sources = others;
             n = sources.length;
@@ -61,72 +61,72 @@ public void call(Subscriber<? super R> t) {
                 sources[n++] = o;
             }
         }
-            
+
         WithLatestMainSubscriber<T, R> parent = new WithLatestMainSubscriber<T, R>(t, combiner, n);
-    
+
         serial.add(parent);
 
-            
+
         for (int i = 0; i < n; i++) {
             if (serial.isUnsubscribed()) {
                 return;
             }
-            
+
             WithLatestOtherSubscriber inner = new WithLatestOtherSubscriber(parent, i + 1);
             parent.add(inner);
-            
+
             Observable<?> o = sources[i];
             o.unsafeSubscribe(inner);
         }
-        
+
         main.unsafeSubscribe(parent);
     }
-    
+
     static final class WithLatestMainSubscriber<T, R> extends Subscriber<T> {
         final Subscriber<? super R> actual;
-        
+
         final FuncN<R> combiner;
-        
+
         final AtomicReferenceArray<Object> current;
-        
+
         static final Object EMPTY = new Object();
-        
+
         final AtomicInteger ready;
-        
+
         boolean done;
-        
+
         public WithLatestMainSubscriber(Subscriber<? super R> actual, FuncN<R> combiner, int n) {
             this.actual = actual;
             this.combiner = combiner;
-            
+
             AtomicReferenceArray<Object> array = new AtomicReferenceArray<Object>(n + 1);
             for (int i = 0; i <= n; i++) {
                 array.lazySet(i, EMPTY);
             }
             this.current = array;
-            
+
             this.ready = new AtomicInteger(n);
             this.request(0);
         }
-        
+
         @Override
         public void onNext(T t) {
             if (done) {
                 return;
             }
             if (ready.get() == 0) {
-                
+
                 AtomicReferenceArray<Object> array = current;
                 int n = array.length();
                 array.lazySet(0, t);
-                
+
                 Object[] copy = new Object[array.length()];
                 for (int i = 0; i < n; i++) {
                     copy[i] = array.get(i);
                 }
-                
+
                 R result;
-                
+
                 try {
                     result = combiner.call(copy);
                 } catch (Throwable ex) {
@@ -134,13 +134,13 @@ public void onNext(T t) {
                     onError(ex);
                     return;
                 }
-                
+
                 actual.onNext(result);
             } else {
                 request(1);
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             if (done) {
@@ -151,7 +151,7 @@ public void onError(Throwable e) {
             unsubscribe();
             actual.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             if (done) {
@@ -161,51 +161,51 @@ public void onCompleted() {
             unsubscribe();
             actual.onCompleted();
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             super.setProducer(p);
             actual.setProducer(p);
         }
-        
+
         void innerNext(int index, Object o) {
             Object last = current.getAndSet(index, o);
             if (last == EMPTY) {
                 ready.decrementAndGet();
             }
         }
-        
+
         void innerError(int index, Throwable e) {
             onError(e);
         }
-        
+
         void innerComplete(int index) {
             if (current.get(index) == EMPTY) {
                 onCompleted();
             }
         }
     }
-    
+
     static final class WithLatestOtherSubscriber extends Subscriber<Object> {
         final WithLatestMainSubscriber<?, ?> parent;
-        
+
         final int index;
 
         public WithLatestOtherSubscriber(WithLatestMainSubscriber<?, ?> parent, int index) {
             this.parent = parent;
             this.index = index;
         }
-        
+
         @Override
         public void onNext(Object t) {
             parent.innerNext(index, t);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             parent.innerError(index, e);
         }
-        
+
         @Override
         public void onCompleted() {
             parent.innerComplete(index);
diff --git a/src/main/java/rx/internal/operators/OperatorZip.java b/src/main/java/rx/internal/operators/OperatorZip.java
index b3e3738737..dbc07c430b 100644
--- a/src/main/java/rx/internal/operators/OperatorZip.java
+++ b/src/main/java/rx/internal/operators/OperatorZip.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -37,7 +37,7 @@
  * <p>
  * The resulting Observable returned from zip will invoke <code>onNext</code> as many times as the
  * number of <code>onNext</code> invocations of the source Observable that emits the fewest items.
- * 
+ *
  * @param <R>
  *            the result type
  */
@@ -102,7 +102,7 @@ public Subscriber<? super Observable[]> call(final Subscriber<? super R> child)
 
         child.add(subscriber);
         child.setProducer(producer);
-        
+
         return subscriber;
     }
 
@@ -149,7 +149,7 @@ public void onNext(Observable[] observables) {
     static final class ZipProducer<R> extends AtomicLong implements Producer {
         /** */
         private static final long serialVersionUID = -1216676403723546796L;
-        
+
         final Zip<R> zipper;
 
         public ZipProducer(Zip<R> zipper) {
@@ -168,7 +168,7 @@ public void request(long n) {
     static final class Zip<R> extends AtomicLong {
         /** */
         private static final long serialVersionUID = 5995274816189928317L;
-        
+
         final Observer<? super R> child;
         private final FuncN<? extends R> zipFunction;
         private final CompositeSubscription childSubscription = new CompositeSubscription();
@@ -194,10 +194,10 @@ public void start(@SuppressWarnings("rawtypes") Observable[] os, AtomicLong requ
                 subscribers[i] = io;
                 childSubscription.add(io);
             }
-            
+
             this.requested = requested;
             this.subscribers = subscribers; // full memory barrier: release all above
-            
+
             for (int i = 0; i < os.length; i++) {
                 os[i].unsafeSubscribe((InnerSubscriber) subscribers[i]);
             }
@@ -205,10 +205,10 @@ public void start(@SuppressWarnings("rawtypes") Observable[] os, AtomicLong requ
 
         /**
          * check if we have values for each and emit if we do
-         * 
+         *
          * This will only allow one thread at a time to do the work, but ensures via `counter` increment/decrement
          * that there is always once who acts on each `tick`. Same concept as used in OperationObserveOn.
-         * 
+         *
          */
         @SuppressWarnings("unchecked")
         void tick() {
@@ -296,7 +296,7 @@ final class InnerSubscriber extends Subscriber {
             public void onStart() {
                 request(RxRingBuffer.SIZE);
             }
-            
+
             public void requestMore(long n) {
                 request(n);
             }
diff --git a/src/main/java/rx/internal/operators/OperatorZipIterable.java b/src/main/java/rx/internal/operators/OperatorZipIterable.java
index b850b49d19..1bff49c910 100644
--- a/src/main/java/rx/internal/operators/OperatorZipIterable.java
+++ b/src/main/java/rx/internal/operators/OperatorZipIterable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/operators/SingleDoAfterTerminate.java b/src/main/java/rx/internal/operators/SingleDoAfterTerminate.java
index 7a683ecb78..d3173031d3 100644
--- a/src/main/java/rx/internal/operators/SingleDoAfterTerminate.java
+++ b/src/main/java/rx/internal/operators/SingleDoAfterTerminate.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2015 Netflix, Inc.
- * 
+ *
  * 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.
@@ -27,31 +27,31 @@
  */
 public final class SingleDoAfterTerminate<T> implements Single.OnSubscribe<T> {
     final Single<T> source;
-    
+
     final Action0 action;
 
     public SingleDoAfterTerminate(Single<T> source, Action0 action) {
         this.source = source;
         this.action = action;
     }
-    
+
     @Override
     public void call(SingleSubscriber<? super T> t) {
         SingleDoAfterTerminateSubscriber<T> parent = new SingleDoAfterTerminateSubscriber<T>(t, action);
         t.add(parent);
         source.subscribe(parent);
     }
-    
+
     static final class SingleDoAfterTerminateSubscriber<T> extends SingleSubscriber<T> {
         final SingleSubscriber<? super T> actual;
 
         final Action0 action;
-        
+
         public SingleDoAfterTerminateSubscriber(SingleSubscriber<? super T> actual, Action0 action) {
             this.actual = actual;
             this.action = action;
         }
-        
+
         @Override
         public void onSuccess(T value) {
             try {
@@ -60,7 +60,7 @@ public void onSuccess(T value) {
                 doAction();
             }
         }
-        
+
         @Override
         public void onError(Throwable error) {
             try {
@@ -69,7 +69,7 @@ public void onError(Throwable error) {
                 doAction();
             }
         }
-        
+
         void doAction() {
             try {
                 action.call();
@@ -79,6 +79,6 @@ void doAction() {
             }
         }
     }
-    
-    
+
+
 }
diff --git a/src/main/java/rx/internal/operators/SingleOnSubscribeMap.java b/src/main/java/rx/internal/operators/SingleOnSubscribeMap.java
index 1c188fd67c..a087c0d556 100644
--- a/src/main/java/rx/internal/operators/SingleOnSubscribeMap.java
+++ b/src/main/java/rx/internal/operators/SingleOnSubscribeMap.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -23,45 +23,45 @@
 /**
  * Applies a function of your choosing to every item emitted by an {@code Single}, and emits the results of
  * this transformation as a new {@code Single}.
- * 
+ *
  * @param <T> the input value type
  * @param <R> the return value type
  */
 public final class SingleOnSubscribeMap<T, R> implements Single.OnSubscribe<R> {
 
     final Single<T> source;
-    
+
     final Func1<? super T, ? extends R> transformer;
 
     public SingleOnSubscribeMap(Single<T> source, Func1<? super T, ? extends R> transformer) {
         this.source = source;
         this.transformer = transformer;
     }
-    
+
     @Override
     public void call(final SingleSubscriber<? super R> o) {
         MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
         o.add(parent);
         source.subscribe(parent);
     }
-    
+
     static final class MapSubscriber<T, R> extends SingleSubscriber<T> {
-        
+
         final SingleSubscriber<? super R> actual;
-        
+
         final Func1<? super T, ? extends R> mapper;
 
         boolean done;
-        
+
         public MapSubscriber(SingleSubscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
             this.actual = actual;
             this.mapper = mapper;
         }
-        
+
         @Override
         public void onSuccess(T t) {
             R result;
-            
+
             try {
                 result = mapper.call(t);
             } catch (Throwable ex) {
@@ -70,10 +70,10 @@ public void onSuccess(T t) {
                 onError(OnErrorThrowable.addValueAsLastCause(ex, t));
                 return;
             }
-            
+
             actual.onSuccess(result);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             if (done) {
@@ -81,7 +81,7 @@ public void onError(Throwable e) {
                 return;
             }
             done = true;
-            
+
             actual.onError(e);
         }
     }
diff --git a/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java b/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
index d56a0693b8..a23a1dc362 100644
--- a/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
+++ b/src/main/java/rx/internal/operators/SingleOnSubscribeUsing.java
@@ -32,7 +32,7 @@
 public final class SingleOnSubscribeUsing<T, Resource> implements Single.OnSubscribe<T> {
     final Func0<Resource> resourceFactory;
     final Func1<? super Resource, ? extends Single<? extends T>> singleFactory;
-    final Action1<? super Resource> disposeAction; 
+    final Action1<? super Resource> disposeAction;
     final boolean disposeEagerly;
 
     public SingleOnSubscribeUsing(Func0<Resource> resourceFactory,
@@ -43,11 +43,11 @@ public SingleOnSubscribeUsing(Func0<Resource> resourceFactory,
         this.disposeAction = disposeAction;
         this.disposeEagerly = disposeEagerly;
     }
-    
+
     @Override
     public void call(final SingleSubscriber<? super T> child) {
-        final Resource resource; // NOPMD 
-        
+        final Resource resource; // NOPMD
+
         try {
             resource = resourceFactory.call();
         } catch (Throwable ex) {
@@ -55,21 +55,21 @@ public void call(final SingleSubscriber<? super T> child) {
             child.onError(ex);
             return;
         }
-        
+
         Single<? extends T> single;
-        
+
         try {
             single = singleFactory.call(resource);
         } catch (Throwable ex) {
             handleSubscriptionTimeError(child, resource, ex);
             return;
         }
-        
+
         if (single == null) {
             handleSubscriptionTimeError(child, resource, new NullPointerException("The single"));
             return;
         }
-        
+
         SingleSubscriber<T> parent = new SingleSubscriber<T>() {
             @Override
             public void onSuccess(T value) {
@@ -78,14 +78,14 @@ public void onSuccess(T value) {
                         disposeAction.call(resource);
                     } catch (Throwable ex) {
                         Exceptions.throwIfFatal(ex);
-                        
+
                         child.onError(ex);
                         return;
                     }
                 }
-                
+
                 child.onSuccess(value);
-                
+
                 if (!disposeEagerly) {
                     try {
                         disposeAction.call(resource);
@@ -95,14 +95,14 @@ public void onSuccess(T value) {
                     }
                 }
             }
-            
+
             @Override
             public void onError(Throwable error) {
                 handleSubscriptionTimeError(child, resource, error);
             }
         };
         child.add(parent);
-        
+
         single.subscribe(parent);
     }
 
@@ -117,9 +117,9 @@ void handleSubscriptionTimeError(SingleSubscriber<? super T> t, Resource resourc
                 ex = new CompositeException(Arrays.asList(ex, ex2));
             }
         }
-        
+
         t.onError(ex);
-        
+
         if (!disposeEagerly) {
             try {
                 disposeAction.call(resource);
diff --git a/src/main/java/rx/internal/operators/SingleOperatorZip.java b/src/main/java/rx/internal/operators/SingleOperatorZip.java
index 7622ec600e..96215b9054 100644
--- a/src/main/java/rx/internal/operators/SingleOperatorZip.java
+++ b/src/main/java/rx/internal/operators/SingleOperatorZip.java
@@ -31,7 +31,7 @@ public final class SingleOperatorZip {
     private SingleOperatorZip() {
         throw new IllegalStateException("No instances!");
     }
-    
+
     public static <T, R> Single<R> zip(final Single<? extends T>[] singles, final FuncN<? extends R> zipper) {
         return Single.create(new Single.OnSubscribe<R>() {
             @Override
diff --git a/src/main/java/rx/internal/producers/ProducerArbiter.java b/src/main/java/rx/internal/producers/ProducerArbiter.java
index ca4d220d1b..a734a38488 100644
--- a/src/main/java/rx/internal/producers/ProducerArbiter.java
+++ b/src/main/java/rx/internal/producers/ProducerArbiter.java
@@ -24,19 +24,19 @@
 public final class ProducerArbiter implements Producer {
     long requested;
     Producer currentProducer;
- 
+
     boolean emitting;
     long missedRequested;
     long missedProduced;
     Producer missedProducer;
-     
+
     static final Producer NULL_PRODUCER = new Producer() {
         @Override
         public void request(long n) {
             // deliberately ignored
         }
     };
-     
+
     @Override
     public void request(long n) {
         if (n < 0) {
@@ -60,12 +60,12 @@ public void request(long n) {
                 u = Long.MAX_VALUE;
             }
             requested = u;
-             
+
             Producer p = currentProducer;
             if (p != null) {
                 p.request(n);
             }
-             
+
             emitLoop();
             skipFinal = true;
         } finally {
@@ -76,7 +76,7 @@ public void request(long n) {
             }
         }
     }
-     
+
     public void produced(long n) {
         if (n <= 0) {
             throw new IllegalArgumentException("n > 0 required");
@@ -88,7 +88,7 @@ public void produced(long n) {
             }
             emitting = true;
         }
-         
+
         boolean skipFinal = false;
         try {
             long r = requested;
@@ -99,7 +99,7 @@ public void produced(long n) {
                 }
                 requested = u;
             }
-         
+
             emitLoop();
             skipFinal = true;
         } finally {
@@ -110,7 +110,7 @@ public void produced(long n) {
             }
         }
     }
-     
+
     public void setProducer(Producer newProducer) {
         synchronized (this) {
             if (emitting) {
@@ -125,7 +125,7 @@ public void setProducer(Producer newProducer) {
             if (newProducer != null) {
                 newProducer.request(requested);
             }
-             
+
             emitLoop();
             skipFinal = true;
         } finally {
@@ -136,7 +136,7 @@ public void setProducer(Producer newProducer) {
             }
         }
     }
- 
+
     public void emitLoop() {
         for (;;) {
             long localRequested;
@@ -146,7 +146,7 @@ public void emitLoop() {
                 localRequested = missedRequested;
                 localProduced = missedProduced;
                 localProducer = missedProducer;
-                if (localRequested == 0L 
+                if (localRequested == 0L
                         && localProduced == 0L
                         && localProducer == null) {
                     emitting = false;
@@ -156,9 +156,9 @@ public void emitLoop() {
                 missedProduced = 0L;
                 missedProducer = null;
             }
-             
+
             long r = requested;
-             
+
             if (r != Long.MAX_VALUE) {
                 long u = r + localRequested;
                 if (u < 0 || u == Long.MAX_VALUE) {
diff --git a/src/main/java/rx/internal/producers/ProducerObserverArbiter.java b/src/main/java/rx/internal/producers/ProducerObserverArbiter.java
index 89a876acf9..37c3faeb52 100644
--- a/src/main/java/rx/internal/producers/ProducerObserverArbiter.java
+++ b/src/main/java/rx/internal/producers/ProducerObserverArbiter.java
@@ -32,31 +32,31 @@
  */
 public final class ProducerObserverArbiter<T> implements Producer, Observer<T> {
     final Subscriber<? super T> child;
-     
+
     boolean emitting;
-     
+
     List<T> queue;
-    
+
     Producer currentProducer;
     long requested;
-    
+
     long missedRequested;
     Producer missedProducer;
     Object missedTerminal;
-    
+
     volatile boolean hasError;
-    
+
     static final Producer NULL_PRODUCER = new Producer() {
         @Override
         public void request(long n) {
             // deliberately ignored
         }
     };
-     
+
     public ProducerObserverArbiter(Subscriber<? super T> child) {
         this.child = child;
     }
-     
+
     @Override
     public void onNext(T t) {
         synchronized (this) {
@@ -74,12 +74,12 @@ public void onNext(T t) {
         boolean skipFinal = false;
         try {
             child.onNext(t);
-            
+
             long r = requested;
             if (r != Long.MAX_VALUE) {
                 requested = r - 1;
             }
-            
+
             emitLoop();
             skipFinal = true;
         } finally {
@@ -90,7 +90,7 @@ public void onNext(T t) {
             }
         }
     }
-     
+
     @Override
     public void onError(Throwable e) {
         boolean emit;
@@ -109,7 +109,7 @@ public void onError(Throwable e) {
             hasError = true;
         }
     }
-    
+
     @Override
     public void onCompleted() {
         synchronized (this) {
@@ -121,7 +121,7 @@ public void onCompleted() {
         }
         child.onCompleted();
     }
-    
+
     @Override
     public void request(long n) {
         if (n < 0) {
@@ -160,7 +160,7 @@ public void request(long n) {
             p.request(n);
         }
     }
-    
+
     public void setProducer(Producer p) {
         synchronized (this) {
             if (emitting) {
@@ -186,13 +186,13 @@ public void setProducer(Producer p) {
             p.request(r);
         }
     }
-    
+
     void emitLoop() {
         final Subscriber<? super T> c = child;
 
         long toRequest = 0L;
         Producer requestFrom = null;
-        
+
         outer:
         for (;;) {
             long localRequested;
@@ -222,7 +222,7 @@ void emitLoop() {
                 }
                 return;
             }
-            
+
             boolean empty = q == null || q.isEmpty();
             if (localTerminal != null) {
                 if (localTerminal != Boolean.TRUE) {
diff --git a/src/main/java/rx/internal/producers/QueuedProducer.java b/src/main/java/rx/internal/producers/QueuedProducer.java
index ed892bab30..5f09d35822 100644
--- a/src/main/java/rx/internal/producers/QueuedProducer.java
+++ b/src/main/java/rx/internal/producers/QueuedProducer.java
@@ -25,32 +25,32 @@
 import rx.internal.util.unsafe.*;
 
 /**
- * Producer that holds an unbounded (or custom) queue, handles terminal events, 
+ * Producer that holds an unbounded (or custom) queue, handles terminal events,
  * enqueues values and relays them to a child subscriber on request.
  *
  * @param <T> the value type
  */
 public final class QueuedProducer<T> extends AtomicLong implements Producer, Observer<T> {
-     
+
     /** */
     private static final long serialVersionUID = 7277121710709137047L;
-    
+
     final Subscriber<? super T> child;
     final Queue<Object> queue;
     final AtomicInteger wip;
-    
+
     Throwable error;
     volatile boolean done;
-    
+
     static final Object NULL_SENTINEL = new Object();
-    
+
     /**
      * Constructs an instance with the target child subscriber and an Spsc Linked (Atomic) Queue
      * as the queue implementation.
      * @param child the target child subscriber
      */
     public QueuedProducer(Subscriber<? super T> child) {
-        this(child, UnsafeAccess.isUnsafeAvailable() 
+        this(child, UnsafeAccess.isUnsafeAvailable()
                 ? new SpscLinkedQueue<Object>() : new SpscLinkedAtomicQueue<Object>());
     }
     /**
@@ -63,7 +63,7 @@ public QueuedProducer(Subscriber<? super T> child, Queue<Object> queue) {
         this.queue = queue;
         this.wip = new AtomicInteger();
     }
-     
+
     @Override
     public void request(long n) {
         if (n < 0) {
@@ -74,7 +74,7 @@ public void request(long n) {
             drain();
         }
     }
-    
+
     /**
      * Offers a value to this producer and tries to emit any queued values
      * if the child requests allow it.
@@ -94,28 +94,28 @@ public boolean offer(T value) {
         drain();
         return true;
     }
-    
+
     @Override
     public void onNext(T value) {
         if (!offer(value)) {
             onError(new MissingBackpressureException());
         }
     }
-     
+
     @Override
     public void onError(Throwable e) {
         error = e;
         done = true;
         drain();
     }
-     
+
     @Override
     public void onCompleted() {
         done = true;
         drain();
     }
-    
-    private boolean checkTerminated(boolean isDone, 
+
+    private boolean checkTerminated(boolean isDone,
             boolean isEmpty) {
         if (child.isUnsubscribed()) {
             return true;
@@ -134,7 +134,7 @@ private boolean checkTerminated(boolean isDone,
         }
         return false;
     }
-    
+
     private void drain() {
         if (wip.getAndIncrement() == 0) {
             final Subscriber<? super T> c = child;
@@ -144,12 +144,12 @@ private void drain() {
                 if (checkTerminated(done, q.isEmpty())) {    // (1)
                     return;
                 }
-                 
+
                 wip.lazySet(1);
-                 
+
                 long r = get();
                 long e = 0;
- 
+
                 while (r != 0) {
                     boolean d = done;
                     Object v = q.poll();
@@ -159,7 +159,7 @@ private void drain() {
                     if (v == null) {
                         break;
                     }
-                     
+
                     try {
                         if (v == NULL_SENTINEL) {
                             c.onNext(null);
@@ -175,7 +175,7 @@ private void drain() {
                     r--;
                     e++;
                 }
-                 
+
                 if (e != 0 && get() != Long.MAX_VALUE) {
                     addAndGet(-e);
                 }
diff --git a/src/main/java/rx/internal/producers/QueuedValueProducer.java b/src/main/java/rx/internal/producers/QueuedValueProducer.java
index 53853f2ccc..e750cd2957 100644
--- a/src/main/java/rx/internal/producers/QueuedValueProducer.java
+++ b/src/main/java/rx/internal/producers/QueuedValueProducer.java
@@ -31,23 +31,23 @@
  * @param <T> the value type
  */
 public final class QueuedValueProducer<T> extends AtomicLong implements Producer {
-     
+
     /** */
     private static final long serialVersionUID = 7277121710709137047L;
-    
+
     final Subscriber<? super T> child;
     final Queue<Object> queue;
     final AtomicInteger wip;
-    
+
     static final Object NULL_SENTINEL = new Object();
-    
+
     /**
      * Constructs an instance with the target child subscriber and an Spsc Linked (Atomic) Queue
      * as the queue implementation.
      * @param child the target child subscriber
      */
     public QueuedValueProducer(Subscriber<? super T> child) {
-        this(child, UnsafeAccess.isUnsafeAvailable() 
+        this(child, UnsafeAccess.isUnsafeAvailable()
                 ? new SpscLinkedQueue<Object>() : new SpscLinkedAtomicQueue<Object>());
     }
     /**
@@ -60,7 +60,7 @@ public QueuedValueProducer(Subscriber<? super T> child, Queue<Object> queue) {
         this.queue = queue;
         this.wip = new AtomicInteger();
     }
-     
+
     @Override
     public void request(long n) {
         if (n < 0) {
@@ -71,7 +71,7 @@ public void request(long n) {
             drain();
         }
     }
-    
+
     /**
      * Offers a value to this producer and tries to emit any queued values
      * if the child requests allow it.
@@ -91,7 +91,7 @@ public boolean offer(T value) {
         drain();
         return true;
     }
-    
+
     private void drain() {
         if (wip.getAndIncrement() == 0) {
             final Subscriber<? super T> c = child;
@@ -100,13 +100,13 @@ private void drain() {
                 if (c.isUnsubscribed()) {
                     return;
                 }
- 
+
                 wip.lazySet(1);
-                 
+
                 long r = get();
                 long e = 0;
                 Object v;
-                 
+
                 while (r != 0 && (v = q.poll()) != null) {
                     try {
                         if (v == NULL_SENTINEL) {
@@ -126,7 +126,7 @@ private void drain() {
                     r--;
                     e++;
                 }
-                 
+
                 if (e != 0 && get() != Long.MAX_VALUE) {
                     addAndGet(-e);
                 }
diff --git a/src/main/java/rx/internal/producers/SingleDelayedProducer.java b/src/main/java/rx/internal/producers/SingleDelayedProducer.java
index 3b3f17bcd0..1bc7a58e02 100644
--- a/src/main/java/rx/internal/producers/SingleDelayedProducer.java
+++ b/src/main/java/rx/internal/producers/SingleDelayedProducer.java
@@ -33,12 +33,12 @@ public final class SingleDelayedProducer<T> extends AtomicInteger implements Pro
     final Subscriber<? super T> child;
     /** The value to emit.*/
     T value;
-    
+
     static final int NO_REQUEST_NO_VALUE = 0;
     static final int NO_REQUEST_HAS_VALUE = 1;
     static final int HAS_REQUEST_NO_VALUE = 2;
     static final int HAS_REQUEST_HAS_VALUE = 3;
-  
+
     /**
      * Constructor, wraps the target child subscriber.
      * @param child the child subscriber, not null
@@ -46,7 +46,7 @@ public final class SingleDelayedProducer<T> extends AtomicInteger implements Pro
     public SingleDelayedProducer(Subscriber<? super T> child) {
         this.child = child;
     }
-     
+
     @Override
     public void request(long n) {
         if (n < 0) {
@@ -67,10 +67,10 @@ public void request(long n) {
                     emit(child, value);
                 }
             }
-            return; // NOPMD 
+            return; // NOPMD
         }
     }
-     
+
     public void setValue(T value) {
         for (;;) {
             int s = get();
@@ -85,7 +85,7 @@ public void setValue(T value) {
                     emit(child, value);
                 }
             }
-            return; // NOPMD 
+            return; // NOPMD
         }
     }
     /**
@@ -108,6 +108,6 @@ private static <T> void emit(Subscriber<? super T> c, T v) {
             return;
         }
         c.onCompleted();
-        
+
     }
 }
\ No newline at end of file
diff --git a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
index 99e595fbf0..940fe685f2 100644
--- a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
+++ b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
@@ -26,7 +26,7 @@
 public final class CachedThreadScheduler extends Scheduler implements SchedulerLifecycle {
     private static final long KEEP_ALIVE_TIME = 60;
     private static final TimeUnit KEEP_ALIVE_UNIT = TimeUnit.SECONDS;
-    
+
     static final ThreadWorker SHUTDOWN_THREADWORKER;
 
     static final CachedWorkerPool NONE;
@@ -34,7 +34,7 @@ public final class CachedThreadScheduler extends Scheduler implements SchedulerL
     final ThreadFactory threadFactory;
 
     final AtomicReference<CachedWorkerPool> pool;
-    
+
     static {
         SHUTDOWN_THREADWORKER = new ThreadWorker(RxThreadFactory.NONE);
         SHUTDOWN_THREADWORKER.unsubscribe();
@@ -42,7 +42,7 @@ public final class CachedThreadScheduler extends Scheduler implements SchedulerL
         NONE = new CachedWorkerPool(null, 0, null);
         NONE.shutdown();
     }
-    
+
     static final class CachedWorkerPool {
         private final ThreadFactory threadFactory;
         private final long keepAliveTime;
@@ -126,7 +126,7 @@ void evictExpiredWorkers() {
         long now() {
             return System.nanoTime();
         }
-        
+
         void shutdown() {
             try {
                 if (evictorTask != null) {
@@ -146,7 +146,7 @@ public CachedThreadScheduler(ThreadFactory threadFactory) {
         this.pool = new AtomicReference<CachedWorkerPool>(NONE);
         start();
     }
-    
+
     @Override
     public void start() {
         CachedWorkerPool update =
@@ -168,7 +168,7 @@ public void shutdown() {
             }
         }
     }
-    
+
     @Override
     public Worker createWorker() {
         return new EventLoopWorker(pool.get());
diff --git a/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java b/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
index 4caf2e3218..d050db1954 100644
--- a/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
+++ b/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -42,7 +42,7 @@ public final class EventLoopsScheduler extends Scheduler implements SchedulerLif
         }
         MAX_THREADS = max;
     }
-    
+
     static final PoolWorker SHUTDOWN_WORKER;
     static {
         SHUTDOWN_WORKER = new PoolWorker(RxThreadFactory.NONE);
@@ -53,7 +53,7 @@ public final class EventLoopsScheduler extends Scheduler implements SchedulerLif
     static final FixedSchedulerPool NONE = new FixedSchedulerPool(null, 0);
 
     final ThreadFactory threadFactory;
-    
+
     final AtomicReference<FixedSchedulerPool> pool;
 
     static final class FixedSchedulerPool {
@@ -79,14 +79,14 @@ public PoolWorker getEventLoop() {
             // simple round robin, improvements to come
             return eventLoops[(int)(n++ % c)];
         }
-        
+
         public void shutdown() {
             for (PoolWorker w : eventLoops) {
                 w.unsubscribe();
             }
         }
     }
-    
+
     /**
      * Create a scheduler with pool size equal to the available processor
      * count and using least-recent worker selection policy.
@@ -97,12 +97,12 @@ public EventLoopsScheduler(ThreadFactory threadFactory) {
         this.pool = new AtomicReference<FixedSchedulerPool>(NONE);
         start();
     }
-    
+
     @Override
     public Worker createWorker() {
         return new EventLoopWorker(pool.get().getEventLoop());
     }
-    
+
     @Override
     public void start() {
         FixedSchedulerPool update = new FixedSchedulerPool(threadFactory, MAX_THREADS);
@@ -110,7 +110,7 @@ public void start() {
             update.shutdown();
         }
     }
-    
+
     @Override
     public void shutdown() {
         for (;;) {
@@ -124,7 +124,7 @@ public void shutdown() {
             }
         }
     }
-    
+
     /**
      * Schedules the action directly on one of the event loop workers
      * without the additional infrastructure and checking.
@@ -144,7 +144,7 @@ static final class EventLoopWorker extends Scheduler.Worker {
 
         EventLoopWorker(PoolWorker poolWorker) {
             this.poolWorker = poolWorker;
-            
+
         }
 
         @Override
diff --git a/src/main/java/rx/internal/schedulers/ExecutorScheduler.java b/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
index aa188fc96c..ab80d476b4 100644
--- a/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
+++ b/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
@@ -46,11 +46,11 @@ static final class ExecutorSchedulerWorker extends Scheduler.Worker implements R
         // TODO: use a better performing structure for task tracking
         final CompositeSubscription tasks;
         // TODO: use MpscLinkedQueue once available
-        final ConcurrentLinkedQueue<ScheduledAction> queue; 
+        final ConcurrentLinkedQueue<ScheduledAction> queue;
         final AtomicInteger wip;
-        
+
         final ScheduledExecutorService service;
-        
+
         public ExecutorSchedulerWorker(Executor executor) {
             this.executor = executor;
             this.queue = new ConcurrentLinkedQueue<ScheduledAction>();
@@ -64,9 +64,9 @@ public Subscription schedule(Action0 action) {
             if (isUnsubscribed()) {
                 return Subscriptions.unsubscribed();
             }
-            
+
             action = RxJavaHooks.onScheduledAction(action);
-            
+
             ScheduledAction ea = new ScheduledAction(action, tasks);
             tasks.add(ea);
             queue.offer(ea);
@@ -87,7 +87,7 @@ public Subscription schedule(Action0 action) {
                     throw t;
                 }
             }
-            
+
             return ea;
         }
 
@@ -112,7 +112,7 @@ public void run() {
                 }
             } while (wip.decrementAndGet() != 0);
         }
-        
+
         @Override
         public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
             if (delayTime <= 0) {
@@ -121,9 +121,9 @@ public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
             if (isUnsubscribed()) {
                 return Subscriptions.unsubscribed();
             }
-            
+
             final Action0 decorated = RxJavaHooks.onScheduledAction(action);
-            
+
             final MultipleAssignmentSubscription first = new MultipleAssignmentSubscription();
             final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
             mas.set(first);
@@ -134,7 +134,7 @@ public void call() {
                     tasks.remove(mas);
                 }
             });
-            
+
             ScheduledAction ea = new ScheduledAction(new Action0() {
                 @Override
                 public void call() {
@@ -156,8 +156,8 @@ public void call() {
             // we don't override the current task in mas.
             first.set(ea);
             // we don't need to add ea to tasks because it will be tracked through mas/first
-            
-            
+
+
             try {
                 Future<?> f = service.schedule(ea, delayTime, unit);
                 ea.add(f);
@@ -166,7 +166,7 @@ public void call() {
                 RxJavaHooks.onError(t);
                 throw t;
             }
-            
+
             /*
              * This allows cancelling either the delayed schedule or the actual schedule referenced
              * by mas and makes sure mas is removed from the tasks composite to avoid leaks.
@@ -184,6 +184,6 @@ public void unsubscribe() {
             tasks.unsubscribe();
             queue.clear();
         }
-        
+
     }
 }
diff --git a/src/main/java/rx/internal/schedulers/GenericScheduledExecutorService.java b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorService.java
index 9a22373d4d..9ed0bbc046 100644
--- a/src/main/java/rx/internal/schedulers/GenericScheduledExecutorService.java
+++ b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorService.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -41,12 +41,12 @@ public final class GenericScheduledExecutorService implements SchedulerLifecycle
 
     /* Schedulers needs access to this in order to work with the lifecycle. */
     public final static GenericScheduledExecutorService INSTANCE = new GenericScheduledExecutorService();
-    
+
     private final AtomicReference<ScheduledExecutorService[]> executor;
 
     /** We don't use atomics with this because thread-assignment is random anyway. */
     private static int roundRobin;
-    
+
     private GenericScheduledExecutorService() {
         executor = new AtomicReference<ScheduledExecutorService[]>(NONE);
         start();
@@ -62,10 +62,10 @@ public void start() {
         if (count > 8) {
             count = 8;
         }
-        
+
         // A multi-threaded executor can reorder tasks, having a set of them
         // and handing one of those out on getInstance() ensures a proper order
-        
+
         ScheduledExecutorService[] execs = new ScheduledExecutorService[count];
         for (int i = 0; i < count; i++) {
             execs[i] = GenericScheduledExecutorServiceFactory.create();
@@ -84,7 +84,7 @@ public void start() {
             }
         }
     }
-    
+
     @Override
     public void shutdown() {
         for (;;) {
@@ -101,10 +101,10 @@ public void shutdown() {
             }
         }
     }
-    
+
     /**
      * Returns one of the single-threaded ScheduledExecutorService helper executors.
-     * 
+     *
      * @return {@link ScheduledExecutorService} for generic use.
      */
     public static ScheduledExecutorService getInstance() {
diff --git a/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
index ce4dd8b5b2..2e15c3c4a4 100644
--- a/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
+++ b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
@@ -28,14 +28,14 @@
  */
 enum GenericScheduledExecutorServiceFactory {
     ;
-    
+
     static final String THREAD_NAME_PREFIX = "RxScheduledExecutorPool-";
     static final RxThreadFactory THREAD_FACTORY = new RxThreadFactory(THREAD_NAME_PREFIX);
 
     static ThreadFactory threadFactory() {
         return THREAD_FACTORY;
     }
-    
+
     /**
      * Creates a ScheduledExecutorService (either the default or given by a hook).
      * @return the SchuduledExecutorService created.
@@ -47,8 +47,8 @@ public static ScheduledExecutorService create() {
         }
         return f.call();
     }
-    
-    
+
+
     static ScheduledExecutorService createDefault() {
         return Executors.newScheduledThreadPool(1, threadFactory());
     }
diff --git a/src/main/java/rx/internal/schedulers/NewThreadWorker.java b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
index 5daf41d05a..b8d8d0e90d 100644
--- a/src/main/java/rx/internal/schedulers/NewThreadWorker.java
+++ b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
@@ -55,7 +55,7 @@ public class NewThreadWorker extends Scheduler.Worker implements Subscription {
      * Possible value of {@link #cachedSetRemoveOnCancelPolicyMethod} which means that cancel policy is not supported.
      */
     private static final Object SET_REMOVE_ON_CANCEL_POLICY_METHOD_NOT_SUPPORTED = new Object();
-    
+
     static {
         EXECUTORS = new ConcurrentHashMap<ScheduledThreadPoolExecutor, ScheduledThreadPoolExecutor>();
         PURGE = new AtomicReference<ScheduledExecutorService>();
@@ -71,10 +71,10 @@ public class NewThreadWorker extends Scheduler.Worker implements Subscription {
         SHOULD_TRY_ENABLE_CANCEL_POLICY = !purgeForce
                 && (androidApiVersion == ANDROID_API_VERSION_IS_NOT_ANDROID || androidApiVersion >= 21);
     }
-    /** 
-     * Registers the given executor service and starts the purge thread if not already started. 
+    /**
+     * Registers the given executor service and starts the purge thread if not already started.
      * <p>{@code public} visibility reason: called from other package(s) within RxJava
-     * @param service a scheduled thread pool executor instance 
+     * @param service a scheduled thread pool executor instance
      */
     public static void registerExecutor(ScheduledThreadPoolExecutor service) {
         do {
@@ -90,19 +90,19 @@ public void run() {
                         purgeExecutors();
                     }
                 }, PURGE_FREQUENCY, PURGE_FREQUENCY, TimeUnit.MILLISECONDS);
-                
+
                 break;
             } else {
                 exec.shutdownNow();
             }
         } while (true);
-        
+
         EXECUTORS.putIfAbsent(service, service);
     }
-    /** 
-     * Deregisters the executor service. 
+    /**
+     * Deregisters the executor service.
      * <p>{@code public} visibility reason: called from other package(s) within RxJava
-     * @param service a scheduled thread pool executor instance 
+     * @param service a scheduled thread pool executor instance
      */
     public static void deregisterExecutor(ScheduledExecutorService service) {
         EXECUTORS.remove(service);
@@ -133,10 +133,10 @@ static void purgeExecutors() {
      * If the method returns false, the {@link #registerExecutor(ScheduledThreadPoolExecutor)} may
      * be called to enable the backup option of purging the executors.
      * @param executor the executor to call setRemoveOnCaneclPolicy if available.
-     * @return true if the policy was successfully enabled 
+     * @return true if the policy was successfully enabled
      */
     public static boolean tryEnableCancelPolicy(ScheduledExecutorService executor) {
-        if (SHOULD_TRY_ENABLE_CANCEL_POLICY) { // NOPMD 
+        if (SHOULD_TRY_ENABLE_CANCEL_POLICY) { // NOPMD
             final boolean isInstanceOfScheduledThreadPoolExecutor = executor instanceof ScheduledThreadPoolExecutor;
 
             Method methodToCall;
@@ -202,7 +202,7 @@ static Method findSetRemoveOnCancelPolicyMethod(ScheduledExecutorService executo
 
         return null;
     }
-    
+
     /* package */
     public NewThreadWorker(ThreadFactory threadFactory) {
         ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, threadFactory);
@@ -229,7 +229,7 @@ public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit
 
     /**
      * Schedules the given action by wrapping it into a ScheduledAction on the
-     * underlying ExecutorService, returning the ScheduledAction. 
+     * underlying ExecutorService, returning the ScheduledAction.
      * @param action the action to wrap and schedule
      * @param delayTime the delay in execution
      * @param unit the time unit of the delay
@@ -263,12 +263,12 @@ public ScheduledAction scheduleActual(final Action0 action, long delayTime, Time
 
         return run;
     }
-    
+
     public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit, SubscriptionList parent) {
         Action0 decoratedAction = RxJavaHooks.onScheduledAction(action);
         ScheduledAction run = new ScheduledAction(decoratedAction, parent);
         parent.add(run);
-        
+
         Future<?> f;
         if (delayTime <= 0) {
             f = executor.submit(run);
diff --git a/src/main/java/rx/internal/schedulers/ScheduledAction.java b/src/main/java/rx/internal/schedulers/ScheduledAction.java
index 51db03e250..4fae47c704 100644
--- a/src/main/java/rx/internal/schedulers/ScheduledAction.java
+++ b/src/main/java/rx/internal/schedulers/ScheduledAction.java
@@ -61,7 +61,7 @@ public void run() {
             unsubscribe();
         }
     }
-    
+
     void signalError(Throwable ie) {
         RxJavaHooks.onError(ie);
         Thread thread = Thread.currentThread();
@@ -98,7 +98,7 @@ public void add(Subscription s) {
     public void add(final Future<?> f) {
         cancel.add(new FutureCompleter(f));
     }
-    
+
     /**
      * Adds a parent {@link CompositeSubscription} to this {@code ScheduledAction} so when the action is
      * cancelled or terminates, it can remove itself from this parent.
diff --git a/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java b/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java
index 498030b6ff..3077ec419b 100644
--- a/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java
+++ b/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java
@@ -21,16 +21,16 @@
  * threads.
  */
 public interface SchedulerLifecycle {
-    /** 
-     * Allows the Scheduler instance to start threads 
+    /**
+     * Allows the Scheduler instance to start threads
      * and accept tasks on them.
-     * <p>Implementations should make sure the call is idempotent and threadsafe. 
+     * <p>Implementations should make sure the call is idempotent and threadsafe.
      */
     void start();
-    /** 
-     * Instructs the Scheduler instance to stop threads 
-     * and stop accepting tasks on any outstanding Workers. 
-     * <p>Implementations should make sure the call is idempotent and threadsafe. 
+    /**
+     * Instructs the Scheduler instance to stop threads
+     * and stop accepting tasks on any outstanding Workers.
+     * <p>Implementations should make sure the call is idempotent and threadsafe.
      */
     void shutdown();
 }
\ No newline at end of file
diff --git a/src/main/java/rx/internal/schedulers/SchedulerWhen.java b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
index b53e1ca10e..4363d76da0 100644
--- a/src/main/java/rx/internal/schedulers/SchedulerWhen.java
+++ b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -60,7 +60,7 @@
  * <p>
  * Limit the amount concurrency two at a time without creating a new fix size
  * thread pool:
- * 
+ *
  * <pre>
  * Scheduler limitSched = Schedulers.computation().when(workers -> {
  * 	// use merge max concurrent to limit the number of concurrent
@@ -78,7 +78,7 @@
  * {@link Observable#zip(Observable, Observable, rx.functions.Func2)} where
  * subscribing to the first {@link Observable} could deadlock the subscription
  * to the second.
- * 
+ *
  * <pre>
  * Scheduler limitSched = Schedulers.computation().when(workers -> {
  * 	// use merge max concurrent to limit the number of concurrent
@@ -86,12 +86,12 @@
  * 	return Completable.merge(Observable.merge(workers, 2));
  * });
  * </pre>
- * 
+ *
  * Slowing down the rate to no more than than 1 a second. This suffers from the
  * same problem as the one above I could find an {@link Observable} operator
  * that limits the rate without dropping the values (aka leaky bucket
  * algorithm).
- * 
+ *
  * <pre>
  * Scheduler slowSched = Schedulers.computation().when(workers -> {
  * 	// use concatenate to make each worker happen one at a time.
diff --git a/src/main/java/rx/internal/schedulers/SleepingAction.java b/src/main/java/rx/internal/schedulers/SleepingAction.java
index ef39676e0f..494439b11f 100644
--- a/src/main/java/rx/internal/schedulers/SleepingAction.java
+++ b/src/main/java/rx/internal/schedulers/SleepingAction.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/subscriptions/SequentialSubscription.java b/src/main/java/rx/internal/subscriptions/SequentialSubscription.java
index 4c65e157e7..8bd2a60a9f 100644
--- a/src/main/java/rx/internal/subscriptions/SequentialSubscription.java
+++ b/src/main/java/rx/internal/subscriptions/SequentialSubscription.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -21,7 +21,7 @@
 import rx.subscriptions.Subscriptions;
 
 /**
- * A container of a Subscription that supports operations of SerialSubscription 
+ * A container of a Subscription that supports operations of SerialSubscription
  * and MultipleAssignmentSubscription via methods (update, replace) and extends
  * AtomicReference to reduce allocation count (beware the API leak of AtomicReference!).
  * @since 1.1.9
@@ -35,9 +35,9 @@ public final class SequentialSubscription extends AtomicReference<Subscription>
      * Create an empty SequentialSubscription.
      */
     public SequentialSubscription() {
-        
+
     }
-    
+
     /**
      * Create a SequentialSubscription with the given initial Subscription.
      * @param initial the initial Subscription, may be null
@@ -45,7 +45,7 @@ public SequentialSubscription() {
     public SequentialSubscription(Subscription initial) {
         lazySet(initial);
     }
-    
+
     /**
      * Returns the current contained Subscription (may be null).
      * <p>(Remark: named as such because get() is final).
@@ -58,7 +58,7 @@ public Subscription current() {
         }
         return current;
     }
-    
+
     /**
      * Atomically sets the contained Subscription to the provided next value and unsubscribes
      * the previous value or unsubscribes the next value if this container is unsubscribed.
@@ -76,7 +76,7 @@ public boolean update(Subscription next) {
                 }
                 return false;
             }
-            
+
             if (compareAndSet(current, next)) {
                 if (current != null) {
                     current.unsubscribe();
@@ -88,7 +88,7 @@ public boolean update(Subscription next) {
 
     /**
      * Atomically replaces the contained Subscription to the provided next value but
-     * does not unsubscribe the previous value or unsubscribes the next value if this 
+     * does not unsubscribe the previous value or unsubscribes the next value if this
      * container is unsubscribed.
      * @param next the next Subscription to contain, may be null
      * @return true if the update succeded, false if the container was unsubscribed
@@ -103,13 +103,13 @@ public boolean replace(Subscription next) {
                 }
                 return false;
             }
-            
+
             if (compareAndSet(current, next)) {
                 return true;
             }
         }
     }
-    
+
     /**
      * Atomically tries to set the contained Subscription to the provided next value and unsubscribes
      * the previous value or unsubscribes the next value if this container is unsubscribed.
@@ -130,18 +130,18 @@ public boolean updateWeak(Subscription next) {
         if (compareAndSet(current, next)) {
             return true;
         }
-        
+
         current = get();
-        
+
         if (next != null) {
             next.unsubscribe();
         }
         return current == Unsubscribed.INSTANCE;
     }
-    
+
     /**
      * Atomically tries to replace the contained Subscription to the provided next value but
-     * does not unsubscribe the previous value or unsubscribes the next value if this container 
+     * does not unsubscribe the previous value or unsubscribes the next value if this container
      * is unsubscribed.
      * <p>
      * Unlike {@link #replace(Subscription)}, this doesn't retry if the replace failed
@@ -160,7 +160,7 @@ public boolean replaceWeak(Subscription next) {
         if (compareAndSet(current, next)) {
             return true;
         }
-        
+
         current = get();
         if (current == Unsubscribed.INSTANCE) {
             if (next != null) {
@@ -170,7 +170,7 @@ public boolean replaceWeak(Subscription next) {
         }
         return true;
     }
-    
+
     @Override
     public void unsubscribe() {
         Subscription current = get();
@@ -181,7 +181,7 @@ public void unsubscribe() {
             }
         }
     }
-    
+
     @Override
     public boolean isUnsubscribed() {
         return get() == Unsubscribed.INSTANCE;
diff --git a/src/main/java/rx/internal/subscriptions/Unsubscribed.java b/src/main/java/rx/internal/subscriptions/Unsubscribed.java
index 3bc85c7e9a..a603313b49 100644
--- a/src/main/java/rx/internal/subscriptions/Unsubscribed.java
+++ b/src/main/java/rx/internal/subscriptions/Unsubscribed.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -22,12 +22,12 @@
  */
 public enum Unsubscribed implements Subscription {
     INSTANCE;
-    
+
     @Override
     public boolean isUnsubscribed() {
         return true;
     }
-    
+
     @Override
     public void unsubscribe() {
         // deliberately ignored
diff --git a/src/main/java/rx/internal/util/ActionNotificationObserver.java b/src/main/java/rx/internal/util/ActionNotificationObserver.java
index 162d9371b4..b6d2732347 100644
--- a/src/main/java/rx/internal/util/ActionNotificationObserver.java
+++ b/src/main/java/rx/internal/util/ActionNotificationObserver.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -24,7 +24,7 @@
  * @param <T> the value type
  */
 public final class ActionNotificationObserver<T> implements Observer<T> {
-    
+
     final Action1<Notification<? super T>> onNotification;
 
     public ActionNotificationObserver(Action1<Notification<? super T>> onNotification) {
diff --git a/src/main/java/rx/internal/util/ActionObserver.java b/src/main/java/rx/internal/util/ActionObserver.java
index c7a17791bd..cac8e7b47a 100644
--- a/src/main/java/rx/internal/util/ActionObserver.java
+++ b/src/main/java/rx/internal/util/ActionObserver.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/util/ActionSubscriber.java b/src/main/java/rx/internal/util/ActionSubscriber.java
index 33a88fe5ed..344f0af291 100644
--- a/src/main/java/rx/internal/util/ActionSubscriber.java
+++ b/src/main/java/rx/internal/util/ActionSubscriber.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/internal/util/BackpressureDrainManager.java b/src/main/java/rx/internal/util/BackpressureDrainManager.java
index b2f9555fbc..9fde1e62f7 100644
--- a/src/main/java/rx/internal/util/BackpressureDrainManager.java
+++ b/src/main/java/rx/internal/util/BackpressureDrainManager.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -24,7 +24,7 @@
  * Manages the producer-backpressure-consumer interplay by
  * matching up available elements with requested elements and/or
  * terminal events.
- * 
+ *
  * @since 1.1.0
  */
 @Experimental
@@ -90,7 +90,7 @@ public boolean isTerminated() {
         return terminated;
     }
     /**
-     * Move into a terminal state. 
+     * Move into a terminal state.
      * Call drain() anytime after.
      */
     public void terminate() {
@@ -110,7 +110,7 @@ public void terminate(Throwable error) {
         }
     }
     /**
-     * Move into a terminal state and drain. 
+     * Move into a terminal state and drain.
      */
     public void terminateAndDrain() {
         terminated = true;
diff --git a/src/main/java/rx/internal/util/ExceptionsUtils.java b/src/main/java/rx/internal/util/ExceptionsUtils.java
index b714e7525a..d4cc3c8e3e 100644
--- a/src/main/java/rx/internal/util/ExceptionsUtils.java
+++ b/src/main/java/rx/internal/util/ExceptionsUtils.java
@@ -23,19 +23,19 @@
 
 /**
  * Utility methods for terminal atomics with Throwables.
- * 
+ *
  * @since 1.1.2
  */
 public enum ExceptionsUtils {
     ;
-    
+
     /** The single instance of a Throwable indicating a terminal state. */
     private static final Throwable TERMINATED = new Throwable("Terminated");
-    
+
     /**
      * Atomically sets or combines the error with the contents of the field, wrapping multiple
      * errors into CompositeException if necessary.
-     * 
+     *
      * @param field the target field
      * @param error the error to add
      * @return true if successful, false if the target field contains the terminal Throwable.
@@ -46,7 +46,7 @@ public static boolean addThrowable(AtomicReference<Throwable> field, Throwable e
             if (current == TERMINATED) {
                 return false;
             }
-            
+
             Throwable next;
             if (current == null) {
                 next = error;
@@ -58,17 +58,17 @@ public static boolean addThrowable(AtomicReference<Throwable> field, Throwable e
             } else {
                 next = new CompositeException(current, error);
             }
-            
+
             if (field.compareAndSet(current, next)) {
                 return true;
             }
         }
     }
-    
+
     /**
      * Atomically swaps in the terminal Throwable and returns the previous
      * contents of the field
-     * 
+     *
      * @param field the target field
      * @return the previous contents of the field before the swap, may be null
      */
@@ -79,10 +79,10 @@ public static Throwable terminate(AtomicReference<Throwable> field) {
         }
         return current;
     }
-    
+
     /**
      * Checks if the given field holds the terminated Throwable instance.
-     * 
+     *
      * @param field the target field
      * @return true if the given field holds the terminated Throwable instance
      */
@@ -92,7 +92,7 @@ public static boolean isTerminated(AtomicReference<Throwable> field) {
 
     /**
      * Returns true if the value is the terminated Throwable instance.
-     * 
+     *
      * @param error the error to check
      * @return true if the value is the terminated Throwable instance
      */
diff --git a/src/main/java/rx/internal/util/IndexedRingBuffer.java b/src/main/java/rx/internal/util/IndexedRingBuffer.java
index 1f2b1037d4..8727f95be0 100644
--- a/src/main/java/rx/internal/util/IndexedRingBuffer.java
+++ b/src/main/java/rx/internal/util/IndexedRingBuffer.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -35,7 +35,7 @@
  * - adds per second single-threaded => ~23,200,000 for 10,000
  * - adds + removes per second single-threaded => 15,562,100 for 100
  * - adds + removes per second single-threaded => 8,760,000 for 10,000
- * 
+ *
  * <pre> {@code
  * Benchmark                                              (size)   Mode   Samples        Score  Score error    Units
  * r.i.IndexedRingBufferPerf.indexedRingBufferAdd            100  thrpt         5   263571.721     9856.994    ops/s
@@ -43,7 +43,7 @@
  * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove      100  thrpt         5   139850.115    17143.705    ops/s
  * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove    10000  thrpt         5      809.982       72.931    ops/s
  * } </pre>
- * 
+ *
  * @param <E>
  */
 public final class IndexedRingBuffer<E> implements Subscription {
@@ -67,76 +67,76 @@ protected IndexedRingBuffer<?> createObject() {
     /**
      * Set at 256 ... Android defaults far smaller which likely will never hit the use cases that require the higher buffers.
      * <p>
-     * The 10000 size test represents something that should be a rare use case (merging 10000 concurrent Observables for example) 
-     * 
+     * The 10000 size test represents something that should be a rare use case (merging 10000 concurrent Observables for example)
+     *
      * <pre> {@code
      * ./gradlew benchmarks '-Pjmh=-f 1 -tu s -bm thrpt -wi 5 -i 5 -r 1 .*IndexedRingBufferPerf.*'
-     * 
+     *
      * 1024
-     * 
+     *
      * Benchmark                                              (size)   Mode   Samples        Score  Score error    Units
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd            100  thrpt         5   269292.006     6013.347    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd          10000  thrpt         5     2217.103      163.396    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove      100  thrpt         5   139349.608     9397.232    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove    10000  thrpt         5     1045.323       30.991    ops/s
-     * 
+     *
      * 512
-     * 
+     *
      * Benchmark                                              (size)   Mode   Samples        Score  Score error    Units
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd            100  thrpt         5   270919.870     5381.793    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd          10000  thrpt         5     1724.436       42.287    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove      100  thrpt         5   141478.813     3696.030    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove    10000  thrpt         5      719.447       75.629    ops/s
-     * 
-     * 
+     *
+     *
      * 256
-     * 
+     *
      * Benchmark                                              (size)   Mode   Samples        Score  Score error    Units
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd            100  thrpt         5   272042.605     7954.982    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd          10000  thrpt         5     1101.329       23.566    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove      100  thrpt         5   140479.804     6389.060    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove    10000  thrpt         5      397.306       24.222    ops/s
-     * 
+     *
      * 128
-     * 
+     *
      * Benchmark                                              (size)   Mode   Samples        Score  Score error    Units
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd            100  thrpt         5   263065.312    11168.941    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd          10000  thrpt         5      581.708       17.397    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove      100  thrpt         5   138051.488     4618.935    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove    10000  thrpt         5      176.873       35.669    ops/s
-     * 
+     *
      * 32
-     * 
+     *
      * Benchmark                                              (size)   Mode   Samples        Score  Score error    Units
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd            100  thrpt         5   250737.473    17260.148    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd          10000  thrpt         5      144.725       26.284    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove      100  thrpt         5   118832.832     9082.658    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove    10000  thrpt         5       32.133        8.048    ops/s
-     * 
+     *
      * 8
-     * 
+     *
      * Benchmark                                              (size)   Mode   Samples        Score  Score error    Units
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd            100  thrpt         5   209192.847    25558.124    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd          10000  thrpt         5       26.520        3.100    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove      100  thrpt         5   100200.463     1854.259    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove    10000  thrpt         5        8.456        2.114    ops/s
-     * 
+     *
      * 2
-     * 
+     *
      * Benchmark                                              (size)   Mode   Samples        Score  Score error    Units
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd            100  thrpt         5    96549.208     4427.239    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAdd          10000  thrpt         5        6.637        2.025    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove      100  thrpt         5    34553.169     4904.197    ops/s
      * r.i.IndexedRingBufferPerf.indexedRingBufferAddRemove    10000  thrpt         5        2.159        0.700    ops/s
      * } </pre>
-     * 
+     *
      * Impact of IndexedRingBuffer size on merge
-     * 
+     *
      * <pre> {@code
      * ./gradlew benchmarks '-Pjmh=-f 1 -tu s -bm thrpt -wi 5 -i 5 -r 1 .*OperatorMergePerf.*'
-     * 
+     *
      * 512
-     * 
+     *
      * Benchmark                                          (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorMergePerf.merge1SyncStreamOfN               1  thrpt         5  5282500.038   530541.761    ops/s
      * r.o.OperatorMergePerf.merge1SyncStreamOfN            1000  thrpt         5    49327.272     6382.189    ops/s
@@ -153,10 +153,10 @@ protected IndexedRingBuffer<?> createObject() {
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1         1  thrpt         5  5026522.098   364196.255    ops/s
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1      1000  thrpt         5    34926.819      938.612    ops/s
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1   1000000  thrpt         5       33.342        1.701    ops/s
-     * 
-     * 
+     *
+     *
      * 128
-     * 
+     *
      * Benchmark                                          (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorMergePerf.merge1SyncStreamOfN               1  thrpt         5  5144891.776   271990.561    ops/s
      * r.o.OperatorMergePerf.merge1SyncStreamOfN            1000  thrpt         5    53580.161     2370.204    ops/s
@@ -173,9 +173,9 @@ protected IndexedRingBuffer<?> createObject() {
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1         1  thrpt         5  4953313.642   307512.126    ops/s
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1      1000  thrpt         5    35335.579     2368.377    ops/s
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1   1000000  thrpt         5       37.450        0.655    ops/s
-     * 
+     *
      * 32
-     * 
+     *
      * Benchmark                                          (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorMergePerf.merge1SyncStreamOfN               1  thrpt         5  4975957.497   365423.694    ops/s
      * r.o.OperatorMergePerf.merge1SyncStreamOfN            1000  thrpt         5    52141.226     5056.658    ops/s
@@ -192,9 +192,9 @@ protected IndexedRingBuffer<?> createObject() {
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1         1  thrpt         5  5177255.256   150253.086    ops/s
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1      1000  thrpt         5    34772.490      909.967    ops/s
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1   1000000  thrpt         5       34.847        0.606    ops/s
-     * 
+     *
      * 8
-     * 
+     *
      * Benchmark                                          (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorMergePerf.merge1SyncStreamOfN               1  thrpt         5  5027331.903   337986.410    ops/s
      * r.o.OperatorMergePerf.merge1SyncStreamOfN            1000  thrpt         5    51746.540     3585.450    ops/s
@@ -211,10 +211,10 @@ protected IndexedRingBuffer<?> createObject() {
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1         1  thrpt         5  4993609.293   267975.397    ops/s
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1      1000  thrpt         5    33228.972     1554.924    ops/s
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1   1000000  thrpt         5       32.994        3.615    ops/s
-     * 
-     * 
+     *
+     *
      * 2
-     * 
+     *
      * Benchmark                                          (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorMergePerf.merge1SyncStreamOfN               1  thrpt         5  5103812.234   939461.192    ops/s
      * r.o.OperatorMergePerf.merge1SyncStreamOfN            1000  thrpt         5    51491.116     3790.056    ops/s
@@ -231,7 +231,7 @@ protected IndexedRingBuffer<?> createObject() {
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1         1  thrpt         5  5280829.290  1602542.493    ops/s
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1      1000  thrpt         5    35070.518     3565.672    ops/s
      * r.o.OperatorMergePerf.oneStreamOfNthatMergesIn1   1000000  thrpt         5       34.501        0.991    ops/s
-     * 
+     *
      * } </pre>
      */
     static {
@@ -248,13 +248,13 @@ protected IndexedRingBuffer<?> createObject() {
             try {
                 defaultSize = Integer.parseInt(sizeFromProperty);
             } catch (NumberFormatException e) {
-                System.err.println("Failed to set 'rx.indexed-ring-buffer.size' with value " + sizeFromProperty + " => " + e.getMessage()); // NOPMD 
+                System.err.println("Failed to set 'rx.indexed-ring-buffer.size' with value " + sizeFromProperty + " => " + e.getMessage()); // NOPMD
             }
         }
-        
+
         SIZE = defaultSize;
     }
-    
+
     @SuppressWarnings("unchecked")
     public static <T> IndexedRingBuffer<T> getInstance() {
         return (IndexedRingBuffer<T>) POOL.borrowObject();
@@ -298,7 +298,7 @@ public void unsubscribe() {
 
     /**
      * Add an element and return the index where it was added to allow removal.
-     * 
+     *
      * @param e the element to add
      * @return the index where the element was added
      */
@@ -358,7 +358,7 @@ private ElementSection<E> getElementSection(int index) {
         return a;
     }
 
-    private synchronized int getIndexForAdd() { // NOPMD 
+    private synchronized int getIndexForAdd() { // NOPMD
         /*
          * Synchronized as I haven't yet figured out a way to do this in an atomic way that doesn't involve object allocation
          */
@@ -384,10 +384,10 @@ private synchronized int getIndexForAdd() { // NOPMD
 
     /**
      * Returns -1 if nothing, 0 or greater if the index should be used
-     * 
+     *
      * @return
      */
-    private synchronized int getIndexFromPreviouslyRemoved() { // NOPMD 
+    private synchronized int getIndexFromPreviouslyRemoved() { // NOPMD
         /*
          * Synchronized as I haven't yet figured out a way to do this in an atomic way that doesn't involve object allocation
          */
@@ -407,7 +407,7 @@ private synchronized int getIndexFromPreviouslyRemoved() { // NOPMD
         }
     }
 
-    private synchronized void pushRemovedIndex(int elementIndex) { // NOPMD 
+    private synchronized void pushRemovedIndex(int elementIndex) { // NOPMD
         /*
          * Synchronized as I haven't yet figured out a way to do this in an atomic way that doesn't involve object allocation
          */
diff --git a/src/main/java/rx/internal/util/InternalObservableUtils.java b/src/main/java/rx/internal/util/InternalObservableUtils.java
index 5b4478fd2c..3aca9a0b10 100644
--- a/src/main/java/rx/internal/util/InternalObservableUtils.java
+++ b/src/main/java/rx/internal/util/InternalObservableUtils.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -45,7 +45,7 @@ public enum InternalObservableUtils {
      * A function that converts a List of Observables into an array of Observables.
      */
     public static final ToArrayFunc1 TO_ARRAY = new ToArrayFunc1();
-    
+
     static final ReturnsVoidFunc1 RETURNS_VOID = new ReturnsVoidFunc1();
 
     /**
@@ -68,7 +68,7 @@ public Integer call(Integer count, Object o) {
             return count + 1;
         }
     }
-    
+
     static final class PlusOneLongFunc2 implements Func2<Long, Object, Long> {
         @Override
         public Long call(Long count, Object o) {
@@ -89,7 +89,7 @@ public Observable<?>[] call(List<? extends Observable<?>> o) {
             return o.toArray(new Observable<?>[o.size()]);
         }
     }
-    
+
     /**
      * Returns a Func1 that checks if its argument is null-safe equals with the given
      * constant reference.
@@ -99,14 +99,14 @@ public Observable<?>[] call(List<? extends Observable<?>> o) {
     public static Func1<Object, Boolean> equalsWith(Object other) {
         return new EqualsWithFunc1(other);
     }
-    
+
     static final class EqualsWithFunc1 implements Func1<Object, Boolean> {
         final Object other;
-        
+
         public EqualsWithFunc1(Object other) {
             this.other = other;
         }
-        
+
         @Override
         public Boolean call(Object t) {
             return t == other || (t != null && t.equals(other));
@@ -122,14 +122,14 @@ public Boolean call(Object t) {
     public static Func1<Object, Boolean> isInstanceOf(Class<?> clazz) {
         return new IsInstanceOfFunc1(clazz);
     }
-    
+
     static final class IsInstanceOfFunc1 implements Func1<Object, Boolean> {
         final Class<?> clazz;
-        
+
         public IsInstanceOfFunc1(Class<?> other) {
             this.clazz = other;
         }
-        
+
         @Override
         public Boolean call(Object t) {
             return clazz.isInstance(t);
@@ -145,21 +145,21 @@ public Boolean call(Object t) {
     public static final Func1<Observable<? extends Notification<?>>, Observable<?>> createRepeatDematerializer(Func1<? super Observable<? extends Void>, ? extends Observable<?>> notificationHandler) {
         return new RepeatNotificationDematerializer(notificationHandler);
     }
-    
+
     static final class RepeatNotificationDematerializer implements Func1<Observable<? extends Notification<?>>, Observable<?>> {
-        
+
         final Func1<? super Observable<? extends Void>, ? extends Observable<?>> notificationHandler;
-        
+
         public RepeatNotificationDematerializer(Func1<? super Observable<? extends Void>, ? extends Observable<?>> notificationHandler) {
             this.notificationHandler = notificationHandler;
         }
-        
+
         @Override
         public Observable<?> call(Observable<? extends Notification<?>> notifications) {
             return notificationHandler.call(notifications.map(RETURNS_VOID));
         }
     };
-    
+
     static final class ReturnsVoidFunc1 implements Func1<Object, Void> {
         @Override
         public Void call(Object t) {
@@ -177,11 +177,11 @@ public Void call(Object t) {
      * @return the new Func1 instance
      */
     public static <T, R> Func1<Observable<T>, Observable<R>> createReplaySelectorAndObserveOn(
-            Func1<? super Observable<T>, ? extends Observable<R>> selector, 
+            Func1<? super Observable<T>, ? extends Observable<R>> selector,
                     Scheduler scheduler) {
         return new SelectorAndObserveOn<T, R>(selector, scheduler);
     }
-    
+
     static final class SelectorAndObserveOn<T, R> implements Func1<Observable<T>, Observable<R>> {
         final Func1<? super Observable<T>, ? extends Observable<R>> selector;
         final Scheduler scheduler;
@@ -213,24 +213,24 @@ public static final Func1<Observable<? extends Notification<?>>, Observable<?>>
 
     static final class RetryNotificationDematerializer implements Func1<Observable<? extends Notification<?>>, Observable<?>> {
         final Func1<? super Observable<? extends Throwable>, ? extends Observable<?>> notificationHandler;
-        
+
         public RetryNotificationDematerializer(Func1<? super Observable<? extends Throwable>, ? extends Observable<?>> notificationHandler) {
             this.notificationHandler = notificationHandler;
         }
-        
+
         @Override
         public Observable<?> call(Observable<? extends Notification<?>> notifications) {
             return notificationHandler.call(notifications.map(ERROR_EXTRACTOR));
         }
     }
-    
+
     static final class NotificationErrorExtractor implements Func1<Notification<?>, Throwable> {
         @Override
         public Throwable call(Notification<?> t) {
             return t.getThrowable();
         }
     }
-    
+
     /**
      * Returns a Func0 that supplies the ConnectableObservable returned by calling replay() on the source.
      * @param <T> the input value type
@@ -291,7 +291,7 @@ public ConnectableObservable<T> call() {
      * @param scheduler the scheduler to use for timing information
      * @return the new Func0 instance
      */
-    public static <T> Func0<ConnectableObservable<T>> createReplaySupplier(final Observable<T> source, 
+    public static <T> Func0<ConnectableObservable<T>> createReplaySupplier(final Observable<T> source,
             final long time, final TimeUnit unit, final Scheduler scheduler) {
         return new ReplaySupplierBufferTime<T>(source, time, unit, scheduler);
     }
@@ -328,7 +328,7 @@ public ConnectableObservable<T> call() {
      * @param scheduler the scheduler to use for timing information
      * @return the new Func0 instance
      */
-    public static <T> Func0<ConnectableObservable<T>> createReplaySupplier(final Observable<T> source, 
+    public static <T> Func0<ConnectableObservable<T>> createReplaySupplier(final Observable<T> source,
             final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) {
         return new ReplaySupplierTime<T>(source, bufferSize, time, unit, scheduler);
     }
@@ -365,14 +365,14 @@ public ConnectableObservable<T> call() {
     public static <T, R> Func2<R, T, R> createCollectorCaller(Action2<R, ? super T> collector) {
         return new CollectorCaller<T, R>(collector);
     }
-    
+
     static final class CollectorCaller<T, R> implements Func2<R, T, R> {
         final Action2<R, ? super T> collector;
-        
+
         public CollectorCaller(Action2<R, ? super T> collector) {
             this.collector = collector;
         }
-        
+
         @Override
         public R call(R state, T value) {
             collector.call(state, value);
@@ -386,5 +386,5 @@ public void call(Throwable t) {
             throw new OnErrorNotImplementedException(t);
         }
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/util/LinkedArrayList.java b/src/main/java/rx/internal/util/LinkedArrayList.java
index 35f5254eeb..28ea19435c 100644
--- a/src/main/java/rx/internal/util/LinkedArrayList.java
+++ b/src/main/java/rx/internal/util/LinkedArrayList.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -18,7 +18,7 @@
 import java.util.*;
 
 /**
- * A list implementation which combines an ArrayList with a LinkedList to 
+ * A list implementation which combines an ArrayList with a LinkedList to
  * avoid copying values when the capacity needs to be increased.
  * <p>
  * The class is non final to allow embedding it directly and thus saving on object allocation.
@@ -26,15 +26,15 @@
 public class LinkedArrayList {
     /** The capacity of each array segment. */
     final int capacityHint;
-    /** 
-     * Contains the head of the linked array list if not null. The 
+    /**
+     * Contains the head of the linked array list if not null. The
      * length is always capacityHint + 1 and the last element is an Object[] pointing
      * to the next element of the linked array list.
      */
     Object[] head;
     /** The tail array where new elements will be added. */
     Object[] tail;
-    /** 
+    /**
      * The total size of the list; written after elements have been added (release) and
      * and when read, the value indicates how many elements can be safely read (acquire).
      */
@@ -80,14 +80,14 @@ public void add(Object o) {
      * @return the head object array
      */
     public Object[] head() {
-        return head; // NOPMD 
+        return head; // NOPMD
     }
     /**
      * Returns the tail buffer segment or null if the list is empty.
      * @return the tail object array
      */
     public Object[] tail() {
-        return tail; // NOPMD 
+        return tail; // NOPMD
     }
     /**
      * Returns the total size of the list.
@@ -114,7 +114,7 @@ public int capacityHint() {
         final int cap = capacityHint;
         final int s = size;
         final List<Object> list = new ArrayList<Object>(s + 1);
-        
+
         Object[] h = head();
         int j = 0;
         int k = 0;
@@ -126,7 +126,7 @@ public int capacityHint() {
                 h = (Object[])h[cap];
             }
         }
-        
+
         return list;
     }
     @Override
diff --git a/src/main/java/rx/internal/util/ObjectPool.java b/src/main/java/rx/internal/util/ObjectPool.java
index ec23c5445b..200b8ef0ef 100644
--- a/src/main/java/rx/internal/util/ObjectPool.java
+++ b/src/main/java/rx/internal/util/ObjectPool.java
@@ -1,18 +1,18 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
- * 
+ *
  * Modified from http://www.javacodegeeks.com/2013/08/simple-and-lightweight-pool-implementation.html
  */
 package rx.internal.util;
@@ -34,7 +34,7 @@ public abstract class ObjectPool<T> implements SchedulerLifecycle {
     private final AtomicReference<Future<?>> periodicTask;
 
     public ObjectPool() {
-        this(0, 0, 67); // NOPMD 
+        this(0, 0, 67); // NOPMD
     }
 
     /**
@@ -107,11 +107,11 @@ public void start() {
                 return;
             }
             ScheduledExecutorService w = GenericScheduledExecutorService.getInstance();
-            
+
             Future<?> f;
             try {
                 f = w.scheduleAtFixedRate(new Runnable() {
-        
+
                     @Override
                     public void run() {
                         int size = pool.size();
@@ -128,7 +128,7 @@ public void run() {
                             }
                         }
                     }
-        
+
                 }, validationInterval, validationInterval, TimeUnit.SECONDS);
             } catch (RejectedExecutionException ex) {
                 RxJavaHooks.onError(ex);
@@ -141,7 +141,7 @@ public void run() {
             }
         }
     }
-    
+
     /**
      * Creates a new object.
      *
diff --git a/src/main/java/rx/internal/util/ObserverSubscriber.java b/src/main/java/rx/internal/util/ObserverSubscriber.java
index dbf519c263..6b6a62a0a6 100644
--- a/src/main/java/rx/internal/util/ObserverSubscriber.java
+++ b/src/main/java/rx/internal/util/ObserverSubscriber.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -28,17 +28,17 @@ public final class ObserverSubscriber<T> extends Subscriber<T> {
     public ObserverSubscriber(Observer<? super T> observer) {
         this.observer = observer;
     }
-    
+
     @Override
     public void onNext(T t) {
         observer.onNext(t);
     }
-    
+
     @Override
     public void onError(Throwable e) {
         observer.onError(e);
     }
-    
+
     @Override
     public void onCompleted() {
         observer.onCompleted();
diff --git a/src/main/java/rx/internal/util/OpenHashSet.java b/src/main/java/rx/internal/util/OpenHashSet.java
index 7115b43519..c5dfb29587 100644
--- a/src/main/java/rx/internal/util/OpenHashSet.java
+++ b/src/main/java/rx/internal/util/OpenHashSet.java
@@ -1,18 +1,18 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
- * 
+ *
  * Modified from http://www.javacodegeeks.com/2013/08/simple-and-lightweight-pool-implementation.html
  */
 
@@ -41,11 +41,11 @@ public final class OpenHashSet<T> {
     int maxSize;
     T[] keys;
     private static final int INT_PHI = 0x9E3779B9;
-    
+
     public OpenHashSet() {
         this(16, 0.75f);
     }
-    
+
     /**
      * Creates an OpenHashSet with the initial capacity and load factor of 0.75f.
      * @param capacity the initial capacity
@@ -53,7 +53,7 @@ public OpenHashSet() {
     public OpenHashSet(int capacity) {
         this(capacity, 0.75f);
     }
-    
+
     @SuppressWarnings("unchecked")
     public OpenHashSet(int capacity, float loadFactor) {
         this.loadFactor = loadFactor;
@@ -62,11 +62,11 @@ public OpenHashSet(int capacity, float loadFactor) {
         this.maxSize = (int)(loadFactor * c);
         this.keys = (T[])new Object[c];
     }
-    
+
     public boolean add(T value) {
         final T[] a = keys;
         final int m = mask;
-        
+
         int pos = mix(value.hashCode()) & m;
         T curr = a[pos];
         if (curr != null) {
@@ -112,10 +112,10 @@ public boolean remove(T value) {
             }
         }
     }
-    
+
     boolean removeEntry(int pos, T[] a, int m) {
         size--;
-        
+
         int last;
         int slot;
         T curr;
@@ -129,17 +129,17 @@ boolean removeEntry(int pos, T[] a, int m) {
                     return true;
                 }
                 slot = mix(curr.hashCode()) & m;
-                
+
                 if (last <= pos ? last >= slot || slot > pos : last >= slot && slot > pos) {
                     break;
                 }
-                
+
                 pos = (pos + 1) & m;
             }
             a[last] = curr;
         }
     }
-    
+
     public void clear(Action1<? super T> clearAction) {
         if (size == 0) {
             return;
@@ -155,25 +155,25 @@ public void clear(Action1<? super T> clearAction) {
         Arrays.fill(a, null);
         size = 0;
     }
-    
+
     @SuppressWarnings("unchecked")
     public void terminate() {
         size = 0;
         keys = (T[])new Object[0];
     }
-    
+
     @SuppressWarnings("unchecked")
     void rehash() {
         T[] a = keys;
         int i = a.length;
         int newCap = i << 1;
         int m = newCap - 1;
-        
+
         T[] b = (T[])new Object[newCap];
-        
-        
+
+
         for (int j = size; j-- != 0; ) {
-            while (a[--i] == null); // NOPMD 
+            while (a[--i] == null); // NOPMD
             int pos = mix(a[i].hashCode()) & m;
             if (b[pos] != null) {
                 for (;;) {
@@ -185,26 +185,26 @@ void rehash() {
             }
             b[pos] = a[i];
         }
-        
+
         this.mask = m;
         this.maxSize = (int)(newCap * loadFactor);
         this.keys = b;
     }
-    
+
     static int mix(int x) {
         final int h = x * INT_PHI;
         return h ^ (h >>> 16);
     }
-    
+
     public boolean isEmpty() {
         return size == 0;
     }
-    
+
     /**
      * Returns the raw array of values of this set, watch out for null entires.
      * @return the raw array of values of this set
      */
     public T[] values() {
-        return keys; // NOPMD 
+        return keys; // NOPMD
     }
 }
diff --git a/src/main/java/rx/internal/util/PlatformDependent.java b/src/main/java/rx/internal/util/PlatformDependent.java
index e1a28c8a08..1a48e8067b 100644
--- a/src/main/java/rx/internal/util/PlatformDependent.java
+++ b/src/main/java/rx/internal/util/PlatformDependent.java
@@ -38,7 +38,7 @@ public final class PlatformDependent {
     private PlatformDependent() {
         throw new IllegalStateException("No instances!");
     }
-    
+
     /**
      * Returns {@code true} if and only if the current platform is Android.
      * @return {@code true} if and only if the current platform is Android
@@ -70,7 +70,7 @@ private static int resolveAndroidApiVersion() {
                     .forName("android.os.Build$VERSION", true, getSystemClassLoader())
                     .getField("SDK_INT")
                     .get(null);
-        } catch (Exception e) { // NOPMD 
+        } catch (Exception e) { // NOPMD
             // Can not resolve version of Android API, maybe current platform is not Android
             // or API of resolving current Version of Android API has changed in some release of Android
             return ANDROID_API_VERSION_IS_NOT_ANDROID;
diff --git a/src/main/java/rx/internal/util/RxRingBuffer.java b/src/main/java/rx/internal/util/RxRingBuffer.java
index 1cd9e3df0d..eddbb3e6eb 100644
--- a/src/main/java/rx/internal/util/RxRingBuffer.java
+++ b/src/main/java/rx/internal/util/RxRingBuffer.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -34,94 +34,94 @@ public class RxRingBuffer implements Subscription {
 
     /**
      * Queue implementation testing that led to current choices of data structures:
-     * 
+     *
      * With synchronized LinkedList
      * <pre> {@code
      * Benchmark                                        Mode   Samples        Score  Score error    Units
      * r.i.RxRingBufferPerf.ringBufferAddRemove1       thrpt         5 19118392.046  1002814.238    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1000    thrpt         5    17891.641      252.747    ops/s
-     * 
+     *
      * With MpscPaddedQueue (single consumer, so failing 1 unit test)
-     * 
+     *
      * Benchmark                                        Mode   Samples        Score  Score error    Units
      * r.i.RxRingBufferPerf.ringBufferAddRemove1       thrpt         5 22164483.238  3035027.348    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1000    thrpt         5    23154.303      602.548    ops/s
-     * 
-     * 
+     *
+     *
      * With ConcurrentLinkedQueue (tracking count separately)
-     * 
+     *
      * Benchmark                                        Mode   Samples        Score  Score error    Units
      * r.i.RxRingBufferPerf.ringBufferAddRemove1       thrpt         5 17353906.092   378756.411    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1000    thrpt         5    19224.411     1010.610    ops/s
-     * 
+     *
      * With ConcurrentLinkedQueue (using queue.size() method for count)
-     * 
+     *
      * Benchmark                                        Mode   Samples        Score  Score error    Units
      * r.i.RxRingBufferPerf.ringBufferAddRemove1       thrpt         5 23951121.098  1982380.330    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1000    thrpt         5     1142.351       33.592    ops/s
-     * 
+     *
      * With SynchronizedQueue (synchronized LinkedList ... no object pooling)
-     * 
+     *
      * r.i.RxRingBufferPerf.createUseAndDestroy1       thrpt         5 33231667.136   685757.510    ops/s
      * r.i.RxRingBufferPerf.createUseAndDestroy1000    thrpt         5    74623.614     5493.766    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1       thrpt         5 22907359.257   707026.632    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1000    thrpt         5    22222.410      320.829    ops/s
-     * 
+     *
      * With ArrayBlockingQueue
-     * 
+     *
      * Benchmark                                            Mode   Samples        Score  Score error    Units
      * r.i.RxRingBufferPerf.createUseAndDestroy1       thrpt         5  2389804.664    68990.804    ops/s
      * r.i.RxRingBufferPerf.createUseAndDestroy1000    thrpt         5    27384.274     1411.789    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1       thrpt         5 26497037.559    91176.247    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1000    thrpt         5    17985.144      237.771    ops/s
-     * 
+     *
      * With ArrayBlockingQueue and Object Pool
-     * 
+     *
      * Benchmark                                            Mode   Samples        Score  Score error    Units
      * r.i.RxRingBufferPerf.createUseAndDestroy1       thrpt         5 12465685.522   399070.770    ops/s
      * r.i.RxRingBufferPerf.createUseAndDestroy1000    thrpt         5    27701.294      395.217    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1       thrpt         5 26399625.086   695639.436    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1000    thrpt         5    17985.427      253.190    ops/s
-     * 
+     *
      * With SpscArrayQueue (single consumer, so failing 1 unit test)
      *  - requires access to Unsafe
-     * 
+     *
      * Benchmark                                        Mode   Samples        Score  Score error    Units
      * r.i.RxRingBufferPerf.createUseAndDestroy1       thrpt         5  1922996.035    49183.766    ops/s
      * r.i.RxRingBufferPerf.createUseAndDestroy1000    thrpt         5    70890.186     1382.550    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1       thrpt         5 80637811.605  3509706.954    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1000    thrpt         5    71822.453     4127.660    ops/s
-     * 
-     * 
+     *
+     *
      * With SpscArrayQueue and Object Pool (object pool improves createUseAndDestroy1 by 10x)
-     * 
+     *
      * Benchmark                                        Mode   Samples        Score  Score error    Units
      * r.i.RxRingBufferPerf.createUseAndDestroy1       thrpt         5 25220069.264  1329078.785    ops/s
      * r.i.RxRingBufferPerf.createUseAndDestroy1000    thrpt         5    72313.457     3535.447    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1       thrpt         5 81863840.884  2191416.069    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1000    thrpt         5    73140.822     1528.764    ops/s
-     * 
+     *
      * With SpmcArrayQueue
      *  - requires access to Unsafe
-     *  
+     *
      * Benchmark                                            Mode   Samples        Score  Score error    Units
      * r.i.RxRingBufferPerf.spmcCreateUseAndDestroy1       thrpt         5 27630345.474   769219.142    ops/s
      * r.i.RxRingBufferPerf.spmcCreateUseAndDestroy1000    thrpt         5    80052.046     4059.541    ops/s
      * r.i.RxRingBufferPerf.spmcRingBufferAddRemove1       thrpt         5 44449524.222   563068.793    ops/s
      * r.i.RxRingBufferPerf.spmcRingBufferAddRemove1000    thrpt         5    65231.253     1805.732    ops/s
-     * 
+     *
      * With SpmcArrayQueue and ObjectPool (object pool improves createUseAndDestroy1 by 10x)
-     * 
+     *
      * Benchmark                                        Mode   Samples        Score  Score error    Units
      * r.i.RxRingBufferPerf.createUseAndDestroy1       thrpt         5 18489343.061  1011872.825    ops/s
      * r.i.RxRingBufferPerf.createUseAndDestroy1000    thrpt         5    46416.434     1439.144    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove        thrpt         5 38280945.847  1071801.279    ops/s
      * r.i.RxRingBufferPerf.ringBufferAddRemove1000    thrpt         5    42337.663     1052.231    ops/s
-     * 
+     *
      * --------------
-     * 
+     *
      * When UnsafeAccess.isUnsafeAvailable() == true we can use the Spmc/SpscArrayQueue implementations.
-     * 
+     *
      * } </pre>
      */
 
@@ -145,12 +145,12 @@ public class RxRingBuffer implements Subscription {
     // default size of ring buffer
     /**
      * 128 was chosen as the default based on the numbers below. A stream processing system may benefit from increasing to 512+.
-     * 
+     *
      * <pre> {@code
      * ./gradlew benchmarks '-Pjmh=-f 1 -tu s -bm thrpt -wi 5 -i 5 -r 1 .*OperatorObserveOnPerf.*'
-     * 
+     *
      * 1024
-     * 
+     *
      * Benchmark                                         (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorObserveOnPerf.observeOnComputation         1  thrpt         5   100642.874    24676.478    ops/s
      * r.o.OperatorObserveOnPerf.observeOnComputation      1000  thrpt         5     4095.901       90.730    ops/s
@@ -161,9 +161,9 @@ public class RxRingBuffer implements Subscription {
      * r.o.OperatorObserveOnPerf.observeOnNewThread           1  thrpt         5    16864.641     1826.877    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread        1000  thrpt         5     4269.317      169.480    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread     1000000  thrpt         5       13.393        1.047    ops/s
-     * 
+     *
      * 512
-     * 
+     *
      * Benchmark                                         (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorObserveOnPerf.observeOnComputation         1  thrpt         5    98945.980    48050.282    ops/s
      * r.o.OperatorObserveOnPerf.observeOnComputation      1000  thrpt         5     4111.149       95.987    ops/s
@@ -174,9 +174,9 @@ public class RxRingBuffer implements Subscription {
      * r.o.OperatorObserveOnPerf.observeOnNewThread           1  thrpt         5    15813.984     8260.170    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread        1000  thrpt         5     4358.334      251.609    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread     1000000  thrpt         5       13.647        0.613    ops/s
-     * 
+     *
      * 256
-     * 
+     *
      * Benchmark                                         (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorObserveOnPerf.observeOnComputation         1  thrpt         5   108489.834     2688.489    ops/s
      * r.o.OperatorObserveOnPerf.observeOnComputation      1000  thrpt         5     4526.674      728.019    ops/s
@@ -187,9 +187,9 @@ public class RxRingBuffer implements Subscription {
      * r.o.OperatorObserveOnPerf.observeOnNewThread           1  thrpt         5    16976.775      968.191    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread        1000  thrpt         5     6238.210     2060.387    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread     1000000  thrpt         5       13.465        0.566    ops/s
-     * 
+     *
      * 128
-     * 
+     *
      * Benchmark                                         (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorObserveOnPerf.observeOnComputation         1  thrpt         5   106887.027    29307.913    ops/s
      * r.o.OperatorObserveOnPerf.observeOnComputation      1000  thrpt         5     6713.891      202.989    ops/s
@@ -200,9 +200,9 @@ public class RxRingBuffer implements Subscription {
      * r.o.OperatorObserveOnPerf.observeOnNewThread           1  thrpt         5    17172.274      236.816    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread        1000  thrpt         5     7073.555      595.990    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread     1000000  thrpt         5       11.855        1.093    ops/s
-     * 
+     *
      * 32
-     * 
+     *
      * Benchmark                                         (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorObserveOnPerf.observeOnComputation         1  thrpt         5   106128.589    20986.201    ops/s
      * r.o.OperatorObserveOnPerf.observeOnComputation      1000  thrpt         5     6396.607       73.627    ops/s
@@ -213,9 +213,9 @@ public class RxRingBuffer implements Subscription {
      * r.o.OperatorObserveOnPerf.observeOnNewThread           1  thrpt         5    16927.513      606.692    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread        1000  thrpt         5     5191.084      244.876    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread     1000000  thrpt         5        8.288        0.217    ops/s
-     * 
+     *
      * 16
-     * 
+     *
      * Benchmark                                         (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorObserveOnPerf.observeOnComputation         1  thrpt         5   109974.741      839.064    ops/s
      * r.o.OperatorObserveOnPerf.observeOnComputation      1000  thrpt         5     4538.912      173.561    ops/s
@@ -226,9 +226,9 @@ public class RxRingBuffer implements Subscription {
      * r.o.OperatorObserveOnPerf.observeOnNewThread           1  thrpt         5    14903.686     3325.205    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread        1000  thrpt         5     3784.776     1054.131    ops/s
      * r.o.OperatorObserveOnPerf.observeOnNewThread     1000000  thrpt         5        5.624        0.130    ops/s
-     * 
+     *
      * 2
-     * 
+     *
      * Benchmark                                         (size)   Mode   Samples        Score  Score error    Units
      * r.o.OperatorObserveOnPerf.observeOnComputation         1  thrpt         5   112663.216      899.005    ops/s
      * r.o.OperatorObserveOnPerf.observeOnComputation      1000  thrpt         5      899.737        9.460    ops/s
@@ -255,7 +255,7 @@ public class RxRingBuffer implements Subscription {
             try {
                 defaultSize = Integer.parseInt(sizeFromProperty);
             } catch (NumberFormatException e) {
-                System.err.println("Failed to set 'rx.buffer.size' with value " + sizeFromProperty + " => " + e.getMessage()); // NOPMD 
+                System.err.println("Failed to set 'rx.buffer.size' with value " + sizeFromProperty + " => " + e.getMessage()); // NOPMD
             }
         }
 
@@ -311,7 +311,7 @@ private RxRingBuffer(ObjectPool<Queue<Object>> pool, int size) {
         this.size = size;
     }
 
-    public synchronized void release() { // NOPMD 
+    public synchronized void release() { // NOPMD
         Queue<Object> q = queue;
         ObjectPool<Queue<Object>> p = pool;
         if (p != null && q != null) {
@@ -331,7 +331,7 @@ public void unsubscribe() {
     }
 
     /**
-     * 
+     *
      * @param o
      * @throws MissingBackpressureException
      *             if more onNext are sent than have been requested
@@ -347,7 +347,7 @@ public void onNext(Object o) throws MissingBackpressureException {
                 iae = true;
             }
         }
-        
+
         if (iae) {
             throw new IllegalStateException("This instance has been unsubscribed and the queue is no longer usable.");
         }
@@ -403,7 +403,7 @@ public Object poll() {
                 return null;
             }
             o = q.poll();
-            
+
             Object ts = terminalState;
             if (o == null && ts != null && q.peek() == null) {
                 o = ts;
diff --git a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
index af2f102021..577b48af3f 100644
--- a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
+++ b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -61,7 +61,7 @@ static <T> Producer createProducer(Subscriber<? super T> s, T v) {
         }
         return new WeakSingleProducer<T>(s, v);
     }
-    
+
     /**
      * Constructs a ScalarSynchronousObservable with the given constant value.
      * @param <T> the value type
@@ -84,8 +84,8 @@ protected ScalarSynchronousObservable(final T t) {
     public T get() {
         return t;
     }
-    
-    
+
+
     /**
      * Customized observeOn/subscribeOn implementation which emits the scalar
      * value directly or with less overhead on the specified scheduler.
@@ -121,10 +121,10 @@ public void call() {
                 }
             };
         }
-        
+
         return create(new ScalarAsyncOnSubscribe<T>(t, onSchedule));
     }
-    
+
     /** The OnSubscribe callback for the Observable constructor. */
     static final class JustOnSubscribe<T> implements OnSubscribe<T> {
         final T value;
@@ -172,7 +172,7 @@ static final class ScalarAsyncProducer<T> extends AtomicBoolean implements Produ
         final Subscriber<? super T> actual;
         final T value;
         final Func1<Action0, Subscription> onSchedule;
-        
+
         public ScalarAsyncProducer(Subscriber<? super T> actual, T value, Func1<Action0, Subscription> onSchedule) {
             this.actual = actual;
             this.value = value;
@@ -188,7 +188,7 @@ public void request(long n) {
                 actual.add(onSchedule.call(this));
             }
         }
-        
+
         @Override
         public void call() {
             Subscriber<? super T> a = actual;
@@ -207,13 +207,13 @@ public void call() {
             }
             a.onCompleted();
         }
-        
+
         @Override
         public String toString() {
             return "ScalarAsyncProducer[" + value + ", " + get() + "]";
         }
     }
-    
+
     /**
      * Given this scalar source as input to a flatMap, avoid one step of subscription
      * and subscribes to the single Observable returned by the function.
@@ -237,7 +237,7 @@ public void call(final Subscriber<? super R> child) {
             }
         });
     }
-    
+
     /**
      * This is the weak version of SingleProducer that uses plain fields
      * to avoid reentrancy and as such is not threadsafe for concurrent
@@ -249,12 +249,12 @@ static final class WeakSingleProducer<T> implements Producer {
         final Subscriber<? super T> actual;
         final T value;
         boolean once;
-        
+
         public WeakSingleProducer(Subscriber<? super T> actual, T value) {
             this.actual = actual;
             this.value = value;
         }
-        
+
         @Override
         public void request(long n) {
             if (once) {
diff --git a/src/main/java/rx/internal/util/SubscriptionList.java b/src/main/java/rx/internal/util/SubscriptionList.java
index c5dc85d388..263cd96fc9 100644
--- a/src/main/java/rx/internal/util/SubscriptionList.java
+++ b/src/main/java/rx/internal/util/SubscriptionList.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -22,7 +22,7 @@
 
 /**
  * Subscription that represents a group of Subscriptions that are unsubscribed together.
- * 
+ *
  * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.disposables.compositedisposable(v=vs.103).aspx">Rx.Net equivalent CompositeDisposable</a>
  */
 public final class SubscriptionList implements Subscription {
diff --git a/src/main/java/rx/internal/util/SynchronizedQueue.java b/src/main/java/rx/internal/util/SynchronizedQueue.java
index 667e9d4083..fda7b70427 100644
--- a/src/main/java/rx/internal/util/SynchronizedQueue.java
+++ b/src/main/java/rx/internal/util/SynchronizedQueue.java
@@ -39,62 +39,62 @@ public SynchronizedQueue(int size) {
     }
 
     @Override
-    public synchronized boolean isEmpty() { // NOPMD 
+    public synchronized boolean isEmpty() { // NOPMD
         return list.isEmpty();
     }
 
     @Override
-    public synchronized boolean contains(Object o) { // NOPMD 
+    public synchronized boolean contains(Object o) { // NOPMD
         return list.contains(o);
     }
 
     @Override
-    public synchronized Iterator<T> iterator() { // NOPMD 
+    public synchronized Iterator<T> iterator() { // NOPMD
         return list.iterator();
     }
 
     @Override
-    public synchronized int size() { // NOPMD 
+    public synchronized int size() { // NOPMD
         return list.size();
     }
 
     @Override
-    public synchronized boolean add(T e) { // NOPMD 
+    public synchronized boolean add(T e) { // NOPMD
         return list.add(e);
     }
 
     @Override
-    public synchronized boolean remove(Object o) { // NOPMD 
+    public synchronized boolean remove(Object o) { // NOPMD
         return list.remove(o);
     }
 
     @Override
-    public synchronized boolean containsAll(Collection<?> c) { // NOPMD 
+    public synchronized boolean containsAll(Collection<?> c) { // NOPMD
         return list.containsAll(c);
     }
 
     @Override
-    public synchronized boolean addAll(Collection<? extends T> c) { // NOPMD 
+    public synchronized boolean addAll(Collection<? extends T> c) { // NOPMD
         return list.addAll(c);
     }
 
     @Override
-    public synchronized boolean removeAll(Collection<?> c) { // NOPMD 
+    public synchronized boolean removeAll(Collection<?> c) { // NOPMD
         return list.removeAll(c);
     }
 
     @Override
-    public synchronized boolean retainAll(Collection<?> c) { // NOPMD 
+    public synchronized boolean retainAll(Collection<?> c) { // NOPMD
         return list.retainAll(c);
     }
 
     @Override
-    public synchronized void clear() { // NOPMD 
+    public synchronized void clear() { // NOPMD
         list.clear();
     }
 
     @Override
-    public synchronized String toString() { // NOPMD 
+    public synchronized String toString() { // NOPMD
         return list.toString();
     }
 
@@ -119,27 +119,27 @@ public boolean equals(Object obj) {
     }
 
     @Override
-    public synchronized T peek() { // NOPMD 
+    public synchronized T peek() { // NOPMD
         return list.peek();
     }
 
     @Override
-    public synchronized T element() { // NOPMD 
+    public synchronized T element() { // NOPMD
         return list.element();
     }
 
     @Override
-    public synchronized T poll() { // NOPMD 
+    public synchronized T poll() { // NOPMD
         return list.poll();
     }
 
     @Override
-    public synchronized T remove() { // NOPMD 
+    public synchronized T remove() { // NOPMD
         return list.remove();
     }
 
     @Override
-    public synchronized boolean offer(T e) { // NOPMD 
+    public synchronized boolean offer(T e) { // NOPMD
         if (size > -1 && list.size() + 1 > size) {
             return false;
         }
@@ -147,19 +147,19 @@ public synchronized boolean offer(T e) { // NOPMD
     }
 
     @Override
-    public synchronized Object clone() { // NOPMD 
+    public synchronized Object clone() { // NOPMD
         SynchronizedQueue<T> q = new SynchronizedQueue<T>(size);
         q.addAll(list);
         return q;
     }
 
     @Override
-    public synchronized Object[] toArray() { // NOPMD 
+    public synchronized Object[] toArray() { // NOPMD
         return list.toArray();
     }
 
     @Override
-    public synchronized <R> R[] toArray(R[] a) { // NOPMD 
+    public synchronized <R> R[] toArray(R[] a) { // NOPMD
         return list.toArray(a);
     }
 
diff --git a/src/main/java/rx/internal/util/UtilityFunctions.java b/src/main/java/rx/internal/util/UtilityFunctions.java
index 68f6da339c..f70b8c295b 100644
--- a/src/main/java/rx/internal/util/UtilityFunctions.java
+++ b/src/main/java/rx/internal/util/UtilityFunctions.java
@@ -1,11 +1,11 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -15,7 +15,7 @@
 import rx.functions.Func1;
 
 /**
- * Utility functions for internal use that we don't want part of the public API. 
+ * Utility functions for internal use that we don't want part of the public API.
  */
 public final class UtilityFunctions {
 
@@ -23,7 +23,7 @@ public final class UtilityFunctions {
     private UtilityFunctions() {
         throw new IllegalStateException("No instances!");
     }
-    
+
     /**
      * Returns a function that always returns {@code true}.
      *
diff --git a/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java b/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java
index 33d45b011b..8a167f0c72 100644
--- a/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/atomic/AtomicReferenceArrayQueue.java
  */
@@ -36,7 +36,7 @@ public Iterator<E> iterator() {
     @Override
     public void clear() {
         // we have to test isEmpty because of the weaker poll() guarantee
-        while (poll() != null || !isEmpty()) ; // NOPMD 
+        while (poll() != null || !isEmpty()) ; // NOPMD
     }
     protected final int calcElementOffset(long index, int mask) {
         return (int)index & mask;
diff --git a/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java b/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
index e9bc346d32..81c12fc645 100644
--- a/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
+++ b/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/atomic/BaseLinkedAtomicQueue.java
  */
@@ -42,7 +42,7 @@ protected final LinkedQueueNode<E> xchgProducerNode(LinkedQueueNode<E> node) {
     protected final LinkedQueueNode<E> lvConsumerNode() {
         return consumerNode.get();
     }
-    
+
     protected final LinkedQueueNode<E> lpConsumerNode() {
         return consumerNode.get();
     }
@@ -59,7 +59,7 @@ public final Iterator<E> iterator() {
      * <p>
      * IMPLEMENTATION NOTES:<br>
      * This is an O(n) operation as we run through all the nodes and count them.<br>
-     * 
+     *
      * @see java.util.Queue#size()
      */
     @Override
@@ -70,7 +70,7 @@ public final int size() {
         // must chase the nodes all the way to the producer node, but there's no need to chase a moving target.
         while (chaserNode != producerNode && size < Integer.MAX_VALUE) {
             LinkedQueueNode<E> next;
-            while((next = chaserNode.lvNext()) == null); // NOPMD 
+            while((next = chaserNode.lvNext()) == null); // NOPMD
             chaserNode = next;
             size++;
         }
diff --git a/src/main/java/rx/internal/util/atomic/LinkedQueueNode.java b/src/main/java/rx/internal/util/atomic/LinkedQueueNode.java
index 719f04e828..a4f481147f 100644
--- a/src/main/java/rx/internal/util/atomic/LinkedQueueNode.java
+++ b/src/main/java/rx/internal/util/atomic/LinkedQueueNode.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/LinkedQueueNode.java
  */
@@ -22,17 +22,17 @@ public final class LinkedQueueNode<E> extends AtomicReference<LinkedQueueNode<E>
     /** */
     private static final long serialVersionUID = 2404266111789071508L;
     private E value;
-    
+
     public LinkedQueueNode() {
         // no initial value
     }
-    
+
     public LinkedQueueNode(E val) {
         spValue(val);
     }
     /**
      * Gets the current value and nulls out the reference to it from this node.
-     * 
+     *
      * @return value
      */
     public E getAndNullValue() {
diff --git a/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java b/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
index b4ef15f91b..6831cbe923 100644
--- a/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
+++ b/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/atomic/MpscLinkedAtomicQueue.java
  */
@@ -26,9 +26,9 @@
  * </ol>
  * The queue is initialized with a stub node which is set to both the producer and consumer node references. From this
  * point follow the notes on offer/poll.
- * 
+ *
  * @author nitsanw
- * 
+ *
  * @param <E>
  */
 public final class MpscLinkedAtomicQueue<E> extends BaseLinkedAtomicQueue<E> {
@@ -51,7 +51,7 @@ public MpscLinkedAtomicQueue() {
      * </ol>
      * This works because each producer is guaranteed to 'plant' a new node and link the old node. No 2 producers can
      * get the same producer node as part of XCHG guarantee.
-     * 
+     *
      * @see java.util.Queue#offer(java.lang.Object)
      */
     @Override
@@ -79,7 +79,7 @@ public boolean offer(final E nextValue) {
      * </ol>
      * This means the consumerNode.value is always null, which is also the starting point for the queue. Because null
      * values are not allowed to be offered this is the only node with it's value set to null at any one time.
-     * 
+     *
      * @see java.util.Queue#poll()
      */
     @Override
@@ -94,9 +94,9 @@ public E poll() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD 
+            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD
             // got the next node...
-            
+
             // we have to null out the value because we are going to hang on to the node
             final E nextValue = nextNode.getAndNullValue();
             spConsumerNode(nextNode);
@@ -114,7 +114,7 @@ public E peek() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD 
+            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD
             // got the next node...
             return nextNode.lpValue();
         }
diff --git a/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
index 03ec839c07..3cd0b0e81f 100644
--- a/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/atomic/SpscAtomicArrayQueue.java
  */
@@ -29,7 +29,7 @@
  * <i>2010 - Pisa - SPSC Queues on Shared Cache Multi-Core Systems.pdf<br>
  * 2012 - Junchang- BQueue- Efficient and Practical Queuing.pdf <br>
  * </i> This implementation is wait free.
- * 
+ *
  * @param <E>
  */
 public final class SpscAtomicArrayQueue<E> extends AtomicReferenceArrayQueue<E> {
@@ -119,7 +119,7 @@ private void soProducerIndex(long newIndex) {
     private void soConsumerIndex(long newIndex) {
         consumerIndex.lazySet(newIndex);
     }
-    
+
     private long lvConsumerIndex() {
         return consumerIndex.get();
     }
diff --git a/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
index e0d41b21a0..9e9affe472 100644
--- a/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/atomic/SpscAtomicArrayQueue.java
  */
@@ -35,7 +35,7 @@ public final class SpscExactAtomicArrayQueue<T> extends AtomicReferenceArray<T>
     final int capacitySkip;
     final AtomicLong producerIndex;
     final AtomicLong consumerIndex;
-    
+
     public SpscExactAtomicArrayQueue(int capacity) {
         super(Pow2.roundToPowerOfTwo(capacity));
         int len = length();
@@ -44,17 +44,17 @@ public SpscExactAtomicArrayQueue(int capacity) {
         this.producerIndex = new AtomicLong();
         this.consumerIndex = new AtomicLong();
     }
-    
-    
+
+
     @Override
     public boolean offer(T value) {
         if (value == null) {
             throw new NullPointerException();
         }
-        
+
         long pi = producerIndex.get();
         int m = mask;
-        
+
         int fullCheck = (int)(pi + capacitySkip) & m;
         if (get(fullCheck) != null) {
             return false;
@@ -82,13 +82,13 @@ public T peek() {
     }
     @Override
     public void clear() {
-        while (poll() != null || !isEmpty()); // NOPMD 
+        while (poll() != null || !isEmpty()); // NOPMD
     }
     @Override
     public boolean isEmpty() {
         return producerIndex == consumerIndex;
     }
-    
+
     @Override
     public int size() {
         long ci = consumerIndex.get();
@@ -161,5 +161,5 @@ public T remove() {
     public T element() {
         throw new UnsupportedOperationException();
     }
-    
+
 }
diff --git a/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
index a37326f09d..2e3cd27052 100644
--- a/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
@@ -23,14 +23,14 @@
 
 
 /*
- * The code was inspired by the similarly named JCTools class: 
+ * The code was inspired by the similarly named JCTools class:
  * https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/atomic
  */
 
 /**
  * A single-producer single-consumer array-backed queue which can allocate new arrays in case the consumer is slower
  * than the producer.
- * 
+ *
  * @param <T> the element type, not null
  */
 public final class SpscLinkedArrayQueue<T> implements Queue<T> {
@@ -43,7 +43,7 @@ public final class SpscLinkedArrayQueue<T> implements Queue<T> {
     int consumerMask;
     AtomicReferenceArray<Object> consumerBuffer;
     final AtomicLong consumerIndex;
-    
+
     private static final Object HAS_NEXT = new Object();
 
     public SpscLinkedArrayQueue(final int bufferSize) {
@@ -175,10 +175,10 @@ public T peek() {
 
         return (T) e;
     }
-    
+
     @Override
     public void clear() {
-        while (poll() != null || !isEmpty()); // NOPMD 
+        while (poll() != null || !isEmpty()); // NOPMD
     }
 
     @SuppressWarnings("unchecked")
@@ -206,7 +206,7 @@ public int size() {
             }
         }
     }
-    
+
     @Override
     public boolean isEmpty() {
         return lvProducerIndex() == lvConsumerIndex();
@@ -313,7 +313,7 @@ public T remove() {
     public T element() {
         throw new UnsupportedOperationException();
     }
-    
+
     /**
      * Offer two elements at the same time.
      * <p>Don't use the regular offer() with this at all!
@@ -325,9 +325,9 @@ public boolean offer(T first, T second) {
         final AtomicReferenceArray<Object> buffer = producerBuffer;
         final long p = lvProducerIndex();
         final int m = producerMask;
-        
+
         int pi = calcWrappedOffset(p + 2, m);
-        
+
         if (null == lvElement(buffer, pi)) {
             pi = calcWrappedOffset(p, m);
             soElement(buffer, pi + 1, second);
@@ -337,14 +337,14 @@ public boolean offer(T first, T second) {
             final int capacity = buffer.length();
             final AtomicReferenceArray<Object> newBuffer = new AtomicReferenceArray<Object>(capacity);
             producerBuffer = newBuffer;
-            
+
             pi = calcWrappedOffset(p, m);
             soElement(newBuffer, pi + 1, second);// StoreStore
             soElement(newBuffer, pi, first);
             soNext(buffer, newBuffer);
-            
+
             soElement(buffer, pi, HAS_NEXT); // new buffer is visible after element is
-            
+
             soProducerIndex(p + 2);// this ensures correctness on 32bit platforms
         }
 
diff --git a/src/main/java/rx/internal/util/atomic/SpscLinkedAtomicQueue.java b/src/main/java/rx/internal/util/atomic/SpscLinkedAtomicQueue.java
index 9b73da962a..a2de19bf60 100644
--- a/src/main/java/rx/internal/util/atomic/SpscLinkedAtomicQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscLinkedAtomicQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/atomic/SpscLinkedAtomicQueue.java
  */
@@ -26,9 +26,9 @@
  * </ol>
  * The queue is initialized with a stub node which is set to both the producer and consumer node references. From this
  * point follow the notes on offer/poll.
- * 
+ *
  * @author nitsanw
- * 
+ *
  * @param <E>
  */
 public final class SpscLinkedAtomicQueue<E> extends BaseLinkedAtomicQueue<E> {
@@ -43,7 +43,7 @@ public SpscLinkedAtomicQueue() {
 
     /**
      * {@inheritDoc} <br>
-     * 
+     *
      * IMPLEMENTATION NOTES:<br>
      * Offer is allowed from a SINGLE thread.<br>
      * Offer allocates a new node (holding the offered value) and:
@@ -52,7 +52,7 @@ public SpscLinkedAtomicQueue() {
      * <li>Sets the new node as the producerNode
      * </ol>
      * From this follows that producerNode.next is always null and for all other nodes node.next is not null.
-     * 
+     *
      * @see java.util.Queue#offer(java.lang.Object)
      */
     @Override
@@ -68,7 +68,7 @@ public boolean offer(final E nextValue) {
 
     /**
      * {@inheritDoc} <br>
-     * 
+     *
      * IMPLEMENTATION NOTES:<br>
      * Poll is allowed from a SINGLE thread.<br>
      * Poll reads the next node from the consumerNode and:
@@ -78,7 +78,7 @@ public boolean offer(final E nextValue) {
      * </ol>
      * This means the consumerNode.value is always null, which is also the starting point for the queue. Because null
      * values are not allowed to be offered this is the only node with it's value set to null at any one time.
-     * 
+     *
      */
     @Override
     public E poll() {
diff --git a/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
index 017b0a8245..9468173869 100644
--- a/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/atomic/SpscUnboundedAtomicArrayQueue.java
  */
@@ -175,10 +175,10 @@ public T peek() {
 
         return (T) e;
     }
-    
+
     @Override
     public void clear() {
-        while (poll() != null || !isEmpty()); // NOPMD 
+        while (poll() != null || !isEmpty()); // NOPMD
     }
 
     @SuppressWarnings("unchecked")
@@ -206,7 +206,7 @@ public int size() {
             }
         }
     }
-    
+
     @Override
     public boolean isEmpty() {
         return lvProducerIndex() == lvConsumerIndex();
diff --git a/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java b/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
index 0c644b5f64..f2d80eb6c5 100644
--- a/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/atomic/BaseLinkedQueue.java
  */
@@ -36,12 +36,12 @@ abstract class BaseLinkedQueueProducerNodeRef<E> extends BaseLinkedQueuePad0<E>
     protected final void spProducerNode(LinkedQueueNode<E> node) {
         producerNode = node;
     }
-    
+
     @SuppressWarnings("unchecked")
     protected final LinkedQueueNode<E> lvProducerNode() {
         return (LinkedQueueNode<E>) UNSAFE.getObjectVolatile(this, P_NODE_OFFSET);
     }
-    
+
     protected final LinkedQueueNode<E> lpProducerNode() {
         return producerNode;
     }
@@ -59,12 +59,12 @@ abstract class BaseLinkedQueueConsumerNodeRef<E> extends BaseLinkedQueuePad1<E>
     protected final void spConsumerNode(LinkedQueueNode<E> node) {
         consumerNode = node;
     }
-    
+
     @SuppressWarnings("unchecked")
     protected final LinkedQueueNode<E> lvConsumerNode() {
         return (LinkedQueueNode<E>) UNSAFE.getObjectVolatile(this, C_NODE_OFFSET);
     }
-    
+
     protected final LinkedQueueNode<E> lpConsumerNode() {
         return consumerNode;
     }
@@ -72,9 +72,9 @@ protected final LinkedQueueNode<E> lpConsumerNode() {
 
 /**
  * A base data structure for concurrent linked queues.
- * 
+ *
  * @author nitsanw
- * 
+ *
  * @param <E> the element type
  */
 @SuppressAnimalSniffer
@@ -93,7 +93,7 @@ public final Iterator<E> iterator() {
      * <p>
      * IMPLEMENTATION NOTES:<br>
      * This is an O(n) operation as we run through all the nodes and count them.<br>
-     * 
+     *
      * @see java.util.Queue#size()
      */
     @Override
@@ -106,13 +106,13 @@ public final int size() {
         // must chase the nodes all the way to the producer node, but there's no need to chase a moving target.
         while (chaserNode != producerNode && size < Integer.MAX_VALUE) {
             LinkedQueueNode<E> next;
-            while((next = chaserNode.lvNext()) == null); // NOPMD 
+            while((next = chaserNode.lvNext()) == null); // NOPMD
             chaserNode = next;
             size++;
         }
         return size;
     }
-    
+
     /**
      * {@inheritDoc} <br>
      * <p>
@@ -120,7 +120,7 @@ public final int size() {
      * Queue is empty when producerNode is the same as consumerNode. An alternative implementation would be to observe
      * the producerNode.value is null, which also means an empty queue because only the consumerNode.value is allowed to
      * be null.
-     * 
+     *
      * @see MessagePassingQueue#isEmpty()
      */
     @Override
diff --git a/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java b/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
index 7a07fc4271..6b57e9cccc 100644
--- a/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/ConcurrentCircularArrayQueue.java
  */
@@ -38,9 +38,9 @@ abstract class ConcurrentCircularArrayQueueL0Pad<E> extends AbstractQueue<E> imp
  * Load/Store methods using a <i>buffer</i> parameter are provided to allow the prevention of final field reload after a
  * LoadLoad barrier.
  * <p>
- * 
+ *
  * @author nitsanw
- * 
+ *
  * @param <E> the element type
  */
 @SuppressAnimalSniffer
@@ -83,7 +83,7 @@ protected final long calcElementOffset(long index) {
     }
     /**
      * @param index desirable element index
-     * @param mask 
+     * @param mask
      * @return the offset in bytes within the array for a given index.
      */
     protected final long calcElementOffset(long index, long mask) {
@@ -91,7 +91,7 @@ protected final long calcElementOffset(long index, long mask) {
     }
     /**
      * A plain store (no ordering/fences) of an element to a given offset
-     * 
+     *
      * @param offset computed via {@link ConcurrentCircularArrayQueue#calcElementOffset(long)}
      * @param e a kitty
      */
@@ -101,7 +101,7 @@ protected final void spElement(long offset, E e) {
 
     /**
      * A plain store (no ordering/fences) of an element to a given offset
-     * 
+     *
      * @param buffer this.buffer
      * @param offset computed via {@link ConcurrentCircularArrayQueue#calcElementOffset(long)}
      * @param e an orderly kitty
@@ -112,7 +112,7 @@ protected final void spElement(E[] buffer, long offset, E e) {
 
     /**
      * An ordered store(store + StoreStore barrier) of an element to a given offset
-     * 
+     *
      * @param offset computed via {@link ConcurrentCircularArrayQueue#calcElementOffset(long)}
      * @param e an orderly kitty
      */
@@ -122,7 +122,7 @@ protected final void soElement(long offset, E e) {
 
     /**
      * An ordered store(store + StoreStore barrier) of an element to a given offset
-     * 
+     *
      * @param buffer this.buffer
      * @param offset computed via {@link ConcurrentCircularArrayQueue#calcElementOffset(long)}
      * @param e an orderly kitty
@@ -133,7 +133,7 @@ protected final void soElement(E[] buffer, long offset, E e) {
 
     /**
      * A plain load (no ordering/fences) of an element from a given offset.
-     * 
+     *
      * @param offset computed via {@link ConcurrentCircularArrayQueue#calcElementOffset(long)}
      * @return the element at the offset
      */
@@ -143,7 +143,7 @@ protected final E lpElement(long offset) {
 
     /**
      * A plain load (no ordering/fences) of an element from a given offset.
-     * 
+     *
      * @param buffer this.buffer
      * @param offset computed via {@link ConcurrentCircularArrayQueue#calcElementOffset(long)}
      * @return the element at the offset
@@ -155,7 +155,7 @@ protected final E lpElement(E[] buffer, long offset) {
 
     /**
      * A volatile load (load + LoadLoad barrier) of an element from a given offset.
-     * 
+     *
      * @param offset computed via {@link ConcurrentCircularArrayQueue#calcElementOffset(long)}
      * @return the element at the offset
      */
@@ -165,7 +165,7 @@ protected final E lvElement(long offset) {
 
     /**
      * A volatile load (load + LoadLoad barrier) of an element from a given offset.
-     * 
+     *
      * @param buffer this.buffer
      * @param offset computed via {@link ConcurrentCircularArrayQueue#calcElementOffset(long)}
      * @return the element at the offset
@@ -182,6 +182,6 @@ public Iterator<E> iterator() {
     @Override
     public void clear() {
         // we have to test isEmpty because of the weaker poll() guarantee
-        while (poll() != null || !isEmpty()) ; // NOPMD 
+        while (poll() != null || !isEmpty()) ; // NOPMD
     }
 }
diff --git a/src/main/java/rx/internal/util/unsafe/ConcurrentSequencedCircularArrayQueue.java b/src/main/java/rx/internal/util/unsafe/ConcurrentSequencedCircularArrayQueue.java
index 1106a4322c..79c605a76a 100644
--- a/src/main/java/rx/internal/util/unsafe/ConcurrentSequencedCircularArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/ConcurrentSequencedCircularArrayQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/ConcurrentSequencedCircularArrayQueue.java
  */
diff --git a/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java b/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java
index f8a87ffec5..4cd0d3fc27 100644
--- a/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java
@@ -2,15 +2,15 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/MessagePassingQueue.java
  */
@@ -24,17 +24,17 @@
  * Message passing queues offer happens before semantics to messages passed through, namely that writes made by the
  * producer before offering the message are visible to the consuming thread after the message has been polled out of the
  * queue.
- * 
+ *
  * @author nitsanw
- * 
+ *
  * @param <M> the event/message type
  */
 public interface MessagePassingQueue<M> {
-    
+
     /**
      * Called from a producer thread subject to the restrictions appropriate to the implementation and according to the
      * {@link Queue#offer(Object)} interface.
-     * 
+     *
      * @param message
      * @return true if element was inserted into the queue, false iff full
      */
@@ -43,7 +43,7 @@ public interface MessagePassingQueue<M> {
     /**
      * Called from the consumer thread subject to the restrictions appropriate to the implementation and according to
      * the {@link Queue#poll()} interface.
-     * 
+     *
      * @return a message from the queue if one is available, null iff empty
      */
     M poll();
@@ -51,7 +51,7 @@ public interface MessagePassingQueue<M> {
     /**
      * Called from the consumer thread subject to the restrictions appropriate to the implementation and according to
      * the {@link Queue#peek()} interface.
-     * 
+     *
      * @return a message from the queue if one is available, null iff empty
      */
     M peek();
@@ -59,14 +59,14 @@ public interface MessagePassingQueue<M> {
     /**
      * This method's accuracy is subject to concurrent modifications happening as the size is estimated and as such is a
      * best effort rather than absolute value. For some implementations this method may be O(n) rather than O(1).
-     * 
+     *
      * @return number of messages in the queue, between 0 and queue capacity or {@link Integer#MAX_VALUE} if not bounded
      */
     int size();
-    
+
     /**
      * This method's accuracy is subject to concurrent modifications happening as the observation is carried out.
-     * 
+     *
      * @return true if empty, false otherwise
      */
     boolean isEmpty();
diff --git a/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java b/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java
index 48ab021d21..d4a5eb2494 100644
--- a/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/MpmcArrayQueue.java
  */
@@ -94,7 +94,7 @@ protected final boolean casConsumerIndex(long expect, long newValue) {
  * <li>Power of 2 capacity: Actual elements buffer (and sequence buffer) is the closest power of 2 larger or
  * equal to the requested capacity.
  * </ol>
- * 
+ *
  * @param <E>
  *            type of the element stored in the {@link java.util.Queue}
  */
diff --git a/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java b/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
index 4fd3ab332d..56b69e09d7 100644
--- a/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/MpscLinkedQueue.java
  */
@@ -31,19 +31,19 @@
  * </ol>
  * The queue is initialized with a stub node which is set to both the producer and consumer node references. From this
  * point follow the notes on offer/poll.
- * 
+ *
  * @author nitsanw
- * 
+ *
  * @param <E>
  */
 @SuppressAnimalSniffer
 public final class MpscLinkedQueue<E> extends BaseLinkedQueue<E> {
-    
+
     public MpscLinkedQueue() {
         consumerNode = new LinkedQueueNode<E>();
         xchgProducerNode(consumerNode);// this ensures correct construction: StoreLoad
     }
-    
+
     @SuppressWarnings("unchecked")
     protected LinkedQueueNode<E> xchgProducerNode(LinkedQueueNode<E> newVal) {
         Object oldVal;
@@ -52,7 +52,7 @@ protected LinkedQueueNode<E> xchgProducerNode(LinkedQueueNode<E> newVal) {
         } while(!UNSAFE.compareAndSwapObject(this, P_NODE_OFFSET, oldVal, newVal));
         return (LinkedQueueNode<E>) oldVal;
     }
-    
+
     /**
      * {@inheritDoc} <br>
      * <p>
@@ -65,7 +65,7 @@ protected LinkedQueueNode<E> xchgProducerNode(LinkedQueueNode<E> newVal) {
      * </ol>
      * This works because each producer is guaranteed to 'plant' a new node and link the old node. No 2 producers can
      * get the same producer node as part of XCHG guarantee.
-     * 
+     *
      * @see MessagePassingQueue#offer(Object)
      * @see java.util.Queue#offer(java.lang.Object)
      */
@@ -94,7 +94,7 @@ public boolean offer(final E nextValue) {
      * </ol>
      * This means the consumerNode.value is always null, which is also the starting point for the queue. Because null
      * values are not allowed to be offered this is the only node with it's value set to null at any one time.
-     * 
+     *
      * @see MessagePassingQueue#poll()
      * @see java.util.Queue#poll()
      */
@@ -110,9 +110,9 @@ public E poll() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD 
+            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD
             // got the next node...
-            
+
             // we have to null out the value because we are going to hang on to the node
             final E nextValue = nextNode.getAndNullValue();
             consumerNode = nextNode;
@@ -130,7 +130,7 @@ public E peek() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD 
+            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD
             // got the next node...
             return nextNode.lpValue();
         }
diff --git a/src/main/java/rx/internal/util/unsafe/Pow2.java b/src/main/java/rx/internal/util/unsafe/Pow2.java
index 528560e6cd..a71a3c2542 100644
--- a/src/main/java/rx/internal/util/unsafe/Pow2.java
+++ b/src/main/java/rx/internal/util/unsafe/Pow2.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/util/Pow2.java
  */
diff --git a/src/main/java/rx/internal/util/unsafe/QueueProgressIndicators.java b/src/main/java/rx/internal/util/unsafe/QueueProgressIndicators.java
index f75152e161..a81c19fccc 100644
--- a/src/main/java/rx/internal/util/unsafe/QueueProgressIndicators.java
+++ b/src/main/java/rx/internal/util/unsafe/QueueProgressIndicators.java
@@ -2,15 +2,15 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/QueueProgressIndicators.java
  */
@@ -20,7 +20,7 @@
  * This interface is provided for monitoring purposes only and is only available on queues where it is easy to
  * provide it. The producer/consumer progress indicators usually correspond with the number of elements
  * offered/polled, but they are not guaranteed to maintain that semantic.
- * 
+ *
  * @author nitsanw
  *
  */
@@ -34,7 +34,7 @@ public interface QueueProgressIndicators {
      * This value will normally indicate number of elements passed into the queue, but may under some
      * circumstances be a derivative of that figure. This method should not be used to derive size or
      * emptiness.
-     * 
+     *
      * @return the current value of the producer progress index
      */
     long currentProducerIndex();
@@ -47,7 +47,7 @@ public interface QueueProgressIndicators {
      * This value will normally indicate number of elements taken out of the queue, but may under some
      * circumstances be a derivative of that figure. This method should not be used to derive size or
      * emptiness.
-     * 
+     *
      * @return the current value of the consumer progress index
      */
     long currentConsumerIndex();
diff --git a/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
index 881eeb242b..325bfd6eae 100644
--- a/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
@@ -2,15 +2,15 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/SpmcArrayQueue.java
  */
@@ -129,13 +129,13 @@ public boolean offer(final E e) {
         final long offset = calcElementOffset(currProducerIndex);
         if (null != lvElement(lb, offset)) {
             long size = currProducerIndex - lvConsumerIndex();
-            
+
             if(size > lMask) {
                 return false;
             }
             else {
                 // spin wait for slot to clear, buggers wait freedom
-                while(null != lvElement(lb, offset)); // NOPMD 
+                while(null != lvElement(lb, offset)); // NOPMD
             }
         }
         spElement(lb, offset, e);
@@ -207,10 +207,10 @@ public int size() {
             }
         }
     }
-    
+
     @Override
     public boolean isEmpty() {
-        // Order matters! 
+        // Order matters!
         // Loading consumer before producer allows for producer increments after consumer index is read.
         // This ensures the correctness of this method at least for the consumer thread. Other threads POV is not really
         // something we can fix here.
diff --git a/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
index 549c6da02c..15c9a9d06f 100644
--- a/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
@@ -2,15 +2,15 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/SpscArrayQueue.java
  */
@@ -86,9 +86,9 @@ public SpscArrayQueueL3Pad(int capacity) {
  * <i>2010 - Pisa - SPSC Queues on Shared Cache Multi-Core Systems.pdf<br>
  * 2012 - Junchang- BQueue- Efficient and Practical Queuing.pdf <br>
  * </i> This implementation is wait free.
- * 
+ *
  * @author nitsanw
- * 
+ *
  * @param <E>
  */
 @SuppressAnimalSniffer
@@ -119,7 +119,7 @@ public boolean offer(final E e) {
         soProducerIndex(index + 1); // ordered store -> atomic and ordered for size()
         return true;
     }
-    
+
     /**
      * {@inheritDoc}
      * <p>
@@ -167,7 +167,7 @@ public int size() {
             }
         }
     }
-    
+
     @Override
     public boolean isEmpty() {
         return lvProducerIndex() == lvConsumerIndex();
@@ -180,11 +180,11 @@ private void soProducerIndex(long v) {
     private void soConsumerIndex(long v) {
         UNSAFE.putOrderedLong(this, C_INDEX_OFFSET, v);
     }
-    
+
     private long lvProducerIndex() {
         return UNSAFE.getLongVolatile(this, P_INDEX_OFFSET);
     }
-    
+
     private long lvConsumerIndex() {
         return UNSAFE.getLongVolatile(this, C_INDEX_OFFSET);
     }
diff --git a/src/main/java/rx/internal/util/unsafe/SpscLinkedQueue.java b/src/main/java/rx/internal/util/unsafe/SpscLinkedQueue.java
index b9a037a986..2a391f5e6b 100644
--- a/src/main/java/rx/internal/util/unsafe/SpscLinkedQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpscLinkedQueue.java
@@ -10,7 +10,7 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/SpscLinkedQueue.java
  */
@@ -31,9 +31,9 @@
  * </ol>
  * The queue is initialized with a stub node which is set to both the producer and consumer node references. From this
  * point follow the notes on offer/poll.
- * 
+ *
  * @author nitsanw
- * 
+ *
  * @param <E>
  */
 public final class SpscLinkedQueue<E> extends BaseLinkedQueue<E> {
@@ -46,7 +46,7 @@ public SpscLinkedQueue() {
 
     /**
      * {@inheritDoc} <br>
-     * 
+     *
      * IMPLEMENTATION NOTES:<br>
      * Offer is allowed from a SINGLE thread.<br>
      * Offer allocates a new node (holding the offered value) and:
@@ -55,7 +55,7 @@ public SpscLinkedQueue() {
      * <li>Sets the new node as the producerNode
      * </ol>
      * From this follows that producerNode.next is always null and for all other nodes node.next is not null.
-     * 
+     *
      * @see MessagePassingQueue#offer(Object)
      * @see java.util.Queue#offer(java.lang.Object)
      */
@@ -72,7 +72,7 @@ public boolean offer(final E nextValue) {
 
     /**
      * {@inheritDoc} <br>
-     * 
+     *
      * IMPLEMENTATION NOTES:<br>
      * Poll is allowed from a SINGLE thread.<br>
      * Poll reads the next node from the consumerNode and:
@@ -82,7 +82,7 @@ public boolean offer(final E nextValue) {
      * </ol>
      * This means the consumerNode.value is always null, which is also the starting point for the queue. Because null
      * values are not allowed to be offered this is the only node with it's value set to null at any one time.
-     * 
+     *
      */
     @Override
     public E poll() {
diff --git a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
index 271ce07dc1..ad752d365b 100644
--- a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
@@ -2,15 +2,15 @@
  * 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.
- * 
+ *
  * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
  * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/queues/SpscUnboundedArrayQueue.java
  */
@@ -284,12 +284,12 @@ private static void soElement(Object[] buffer, long offset, Object e) {
     private static <E> Object lvElement(E[] buffer, long offset) {
         return UNSAFE.getObjectVolatile(buffer, offset);
     }
-    
+
     @Override
     public long currentProducerIndex() {
         return lvProducerIndex();
     }
-    
+
     @Override
     public long currentConsumerIndex() {
         return lvConsumerIndex();
diff --git a/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java b/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
index d3b88cf9cd..d5576b77e7 100644
--- a/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
+++ b/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -43,14 +43,14 @@ private UnsafeAccess() {
         try {
             /*
              * This mechanism for getting UNSAFE originally from:
-             * 
+             *
              * Original License: https://github.com/JCTools/JCTools/blob/master/LICENSE
              * Original location: https://github.com/JCTools/JCTools/blob/master/jctools-core/src/main/java/org/jctools/util/UnsafeAccess.java
              */
             Field field = Unsafe.class.getDeclaredField("theUnsafe");
             field.setAccessible(true);
             u = (Unsafe) field.get(null);
-        } catch (Throwable e) { // NOPMD 
+        } catch (Throwable e) { // NOPMD
             // do nothing, hasUnsafe() will return false
         }
         UNSAFE = u;
@@ -96,7 +96,7 @@ public static int getAndSetInt(Object obj, long offset, int newValue) {
     public static boolean compareAndSwapInt(Object obj, long offset, int expected, int newValue) {
         return UNSAFE.compareAndSwapInt(obj, offset, expected, newValue);
     }
-    
+
     /**
      * Returns the address of the specific field on the class and
      * wraps a NoSuchFieldException into an internal error.
diff --git a/src/main/java/rx/observables/AsyncOnSubscribe.java b/src/main/java/rx/observables/AsyncOnSubscribe.java
index d1394d7547..35eb618736 100644
--- a/src/main/java/rx/observables/AsyncOnSubscribe.java
+++ b/src/main/java/rx/observables/AsyncOnSubscribe.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2015 Netflix, Inc.
- * 
+ *
  * 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.
@@ -52,7 +52,7 @@ public abstract class AsyncOnSubscribe<S, T> implements OnSubscribe<T> {
      * to produce a state value. This value is passed into {@link #next(Object, long, Observer)
      * next(S state, Observer <T> observer)} on the first iteration. Subsequent iterations of
      * {@code next} will receive the state returned by the previous invocation of {@code next}.
-     * 
+     *
      * @return the initial state value
      */
     protected abstract S generateState();
@@ -63,15 +63,15 @@ public abstract class AsyncOnSubscribe<S, T> implements OnSubscribe<T> {
      * {@code observer.onError(throwable)} or throw an Exception. To signal the end of a data stream
      * call {@code observer.onCompleted()}. Implementations of this method must follow the following
      * rules.
-     * 
+     *
      * <ul>
      * <li>Must not call {@code observer.onNext(t)} more than 1 time per invocation.</li>
      * <li>Must not call {@code observer.onNext(t)} concurrently.</li>
      * </ul>
-     * 
+     *
      * The value returned from an invocation of this method will be passed in as the {@code state}
      * argument of the next invocation of this method.
-     * 
+     *
      * @param state
      *            the state value (from {@link #generateState()} on the first invocation or the
      *            previous invocation of this method.
@@ -87,7 +87,7 @@ public abstract class AsyncOnSubscribe<S, T> implements OnSubscribe<T> {
     /**
      * Clean up behavior that is executed after the downstream subscriber's subscription is
      * unsubscribed. This method will be invoked exactly once.
-     * 
+     *
      * @param state
      *            the last state value returned from {@code next(S, Long, Observer)} or
      *            {@code generateState()} at the time when a terminal event is emitted from
@@ -100,7 +100,7 @@ protected void onUnsubscribe(S state) {
     /**
      * Generates a synchronous {@link AsyncOnSubscribe} that calls the provided {@code next}
      * function to generate data to downstream subscribers.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param <S> the type of the associated state with each Subscriber
      * @param generator
@@ -111,9 +111,9 @@ protected void onUnsubscribe(S state) {
      * @return an AsyncOnSubscribe that emits data in a protocol compatible with back-pressure.
      */
     @Experimental
-    public static <S, T> AsyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator, 
+    public static <S, T> AsyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator,
             final Action3<? super S, Long, ? super Observer<Observable<? extends T>>> next) {
-        Func3<S, Long, ? super Observer<Observable<? extends T>>, S> nextFunc = 
+        Func3<S, Long, ? super Observer<Observable<? extends T>>, S> nextFunc =
                 new Func3<S, Long, Observer<Observable<? extends T>>, S>() {
                     @Override
                     public S call(S state, Long requested, Observer<Observable<? extends T>> subscriber) {
@@ -126,9 +126,9 @@ public S call(S state, Long requested, Observer<Observable<? extends T>> subscri
     /**
      * Generates a synchronous {@link AsyncOnSubscribe} that calls the provided {@code next}
      * function to generate data to downstream subscribers.
-     * 
+     *
      * This overload creates a AsyncOnSubscribe without an explicit clean up step.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param <S> the type of the associated state with each Subscriber
      * @param generator
@@ -142,10 +142,10 @@ public S call(S state, Long requested, Observer<Observable<? extends T>> subscri
      *         back-pressure.
      */
     @Experimental
-    public static <S, T> AsyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator, 
-            final Action3<? super S, Long, ? super Observer<Observable<? extends T>>> next, 
+    public static <S, T> AsyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator,
+            final Action3<? super S, Long, ? super Observer<Observable<? extends T>>> next,
             final Action1<? super S> onUnsubscribe) {
-        Func3<S, Long, Observer<Observable<? extends T>>, S> nextFunc = 
+        Func3<S, Long, Observer<Observable<? extends T>>, S> nextFunc =
                 new Func3<S, Long, Observer<Observable<? extends T>>, S>() {
                     @Override
                     public S call(S state, Long requested, Observer<Observable<? extends T>> subscriber) {
@@ -158,7 +158,7 @@ public S call(S state, Long requested, Observer<Observable<? extends T>> subscri
     /**
      * Generates a synchronous {@link AsyncOnSubscribe} that calls the provided {@code next}
      * function to generate data to downstream subscribers.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param <S> the type of the associated state with each Subscriber
      * @param generator
@@ -172,8 +172,8 @@ public S call(S state, Long requested, Observer<Observable<? extends T>> subscri
      *         back-pressure.
      */
     @Experimental
-    public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator, 
-            Func3<? super S, Long, ? super Observer<Observable<? extends T>>, ? extends S> next, 
+    public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator,
+            Func3<? super S, Long, ? super Observer<Observable<? extends T>>, ? extends S> next,
             Action1<? super S> onUnsubscribe) {
         return new AsyncOnSubscribeImpl<S, T>(generator, next, onUnsubscribe);
     }
@@ -181,7 +181,7 @@ public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> ge
     /**
      * Generates a synchronous {@link AsyncOnSubscribe} that calls the provided {@code next}
      * function to generate data to downstream subscribers.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param <S> the type of the associated state with each Subscriber
      * @param generator
@@ -193,7 +193,7 @@ public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> ge
      *         back-pressure.
      */
     @Experimental
-    public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator, 
+    public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator,
             Func3<? super S, Long, ? super Observer<Observable<? extends T>>, ? extends S> next) {
         return new AsyncOnSubscribeImpl<S, T>(generator, next);
     }
@@ -201,10 +201,10 @@ public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> ge
     /**
      * Generates a synchronous {@link AsyncOnSubscribe} that calls the provided {@code next}
      * function to generate data to downstream subscribers.
-     * 
+     *
      * This overload creates a "state-less" AsyncOnSubscribe which does not have an explicit state
      * value. This should be used when the {@code next} function closes over it's state.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param next
      *            produces data to the downstream subscriber (see
@@ -214,7 +214,7 @@ public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> ge
      */
     @Experimental
     public static <T> AsyncOnSubscribe<Void, T> createStateless(final Action2<Long, ? super Observer<Observable<? extends T>>> next) {
-        Func3<Void, Long, Observer<Observable<? extends T>>, Void> nextFunc = 
+        Func3<Void, Long, Observer<Observable<? extends T>>, Void> nextFunc =
                 new Func3<Void, Long, Observer<Observable<? extends T>>, Void>() {
                     @Override
                     public Void call(Void state, Long requested, Observer<Observable<? extends T>> subscriber) {
@@ -227,10 +227,10 @@ public Void call(Void state, Long requested, Observer<Observable<? extends T>> s
     /**
      * Generates a synchronous {@link AsyncOnSubscribe} that calls the provided {@code next}
      * function to generate data to downstream subscribers.
-     * 
+     *
      * This overload creates a "state-less" AsyncOnSubscribe which does not have an explicit state
      * value. This should be used when the {@code next} function closes over it's state.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param next
      *            produces data to the downstream subscriber (see
@@ -241,9 +241,9 @@ public Void call(Void state, Long requested, Observer<Observable<? extends T>> s
      *         back-pressure.
      */
     @Experimental
-    public static <T> AsyncOnSubscribe<Void, T> createStateless(final Action2<Long, ? super Observer<Observable<? extends T>>> next, 
+    public static <T> AsyncOnSubscribe<Void, T> createStateless(final Action2<Long, ? super Observer<Observable<? extends T>>> next,
             final Action0 onUnsubscribe) {
-        Func3<Void, Long, Observer<Observable<? extends T>>, Void> nextFunc = 
+        Func3<Void, Long, Observer<Observable<? extends T>>, Void> nextFunc =
                 new Func3<Void, Long, Observer<Observable<? extends T>>, Void>() {
                     @Override
                     public Void call(Void state, Long requested, Observer<Observable<? extends T>> subscriber) {
@@ -320,38 +320,38 @@ public final void call(final Subscriber<? super T> actualSubscriber) {
             return;
         }
         UnicastSubject<Observable<T>> subject = UnicastSubject.<Observable<T>> create();
-        
+
         final AsyncOuterManager<S, T> outerProducer = new AsyncOuterManager<S, T>(this, state, subject);
-        
+
         Subscriber<T> concatSubscriber = new Subscriber<T>() {
             @Override
             public void onNext(T t) {
                 actualSubscriber.onNext(t);
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 actualSubscriber.onError(e);
             }
-            
+
             @Override
             public void onCompleted() {
                 actualSubscriber.onCompleted();
             }
-            
+
             @Override
             public void setProducer(Producer p) {
                 outerProducer.setConcatProducer(p);
             }
         };
-        
+
         subject.onBackpressureBuffer().concatMap(new Func1<Observable<T>, Observable<T>>() {
             @Override
             public Observable<T> call(Observable<T> v) {
                 return v.onBackpressureBuffer();
             }
         }).unsafeSubscribe(concatSubscriber);
-        
+
         actualSubscriber.add(concatSubscriber);
         actualSubscriber.add(outerProducer);
         actualSubscriber.setProducer(outerProducer);
@@ -372,11 +372,11 @@ static final class AsyncOuterManager<S, T> implements Producer, Subscription, Ob
         private S state;
 
         private final UnicastSubject<Observable<T>> merger;
-        
+
         boolean emitting;
         List<Long> requests;
         Producer concatProducer;
-        
+
         long expectedDelivery;
 
         public AsyncOuterManager(AsyncOnSubscribe<S, T> parent, S initialState, UnicastSubject<Observable<T>> merger) {
@@ -408,7 +408,7 @@ void setConcatProducer(Producer p) {
             }
             concatProducer = p;
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return isUnsubscribed.get();
@@ -417,7 +417,7 @@ public boolean isUnsubscribed() {
         public void nextIteration(long requestCount) {
             state = parent.next(state, requestCount, serializedSubscriber);
         }
-        
+
         void cleanup() {
             subscriptions.unsubscribe();
             try {
@@ -444,19 +444,19 @@ public void request(long n) {
                         requests = q;
                     }
                     q.add(n);
-                    
-                    quit = true; 
+
+                    quit = true;
                 } else {
                     emitting = true;
                 }
             }
-            
+
             concatProducer.request(n);
-            
+
             if (quit) {
                 return;
             }
-            
+
             if (tryEmit(n)) {
                 return;
             }
@@ -470,7 +470,7 @@ public void request(long n) {
                     }
                     requests = null;
                 }
-                
+
                 for (long r : q) {
                     if (tryEmit(r)) {
                         return;
@@ -499,12 +499,12 @@ public void requestRemaining(long n) {
                         requests = q;
                     }
                     q.add(n);
-                    
+
                     return;
                 }
                 emitting = true;
             }
-            
+
             if (tryEmit(n)) {
                 return;
             }
@@ -518,7 +518,7 @@ public void requestRemaining(long n) {
                     }
                     requests = null;
                 }
-                
+
                 for (long r : q) {
                     if (tryEmit(r)) {
                         return;
@@ -532,12 +532,12 @@ boolean tryEmit(long n) {
                 cleanup();
                 return true;
             }
-            
+
             try {
                 onNextCalled = false;
                 expectedDelivery = n;
                 nextIteration(n);
-                
+
                 if (hasTerminated || isUnsubscribed()) {
                     cleanup();
                     return true;
@@ -625,7 +625,7 @@ public void onCompleted() {
                     public void call() {
                         subscriptions.remove(s);
                     }});
-            
+
             ((Observable<T>)doOnTerminate).subscribe(s);
 
             merger.onNext(buffer);
diff --git a/src/main/java/rx/observables/BlockingObservable.java b/src/main/java/rx/observables/BlockingObservable.java
index e9db68f358..d9fd534bf4 100644
--- a/src/main/java/rx/observables/BlockingObservable.java
+++ b/src/main/java/rx/observables/BlockingObservable.java
@@ -90,10 +90,10 @@ public static <T> BlockingObservable<T> from(final Observable<? extends T> o) {
      * need the {@link Subscriber#onCompleted()} or {@link Subscriber#onError(Throwable)} methods. If the
      * underlying Observable terminates with an error, rather than calling {@code onError}, this method will
      * throw an exception.
-     * 
+     *
      * <p>The difference between this method and {@link #subscribe(Action1)} is that the {@code onNext} action
      * is executed on the emission thread instead of the current thread.
-     * 
+     *
      * @param onNext
      *            the {@link Action1} to invoke for each item emitted by the {@code BlockingObservable}
      * @throws RuntimeException
@@ -122,7 +122,7 @@ public void onError(Throwable e) {
                  * If we receive an onError event we set the reference on the
                  * outer thread so we can git it and throw after the
                  * latch.await().
-                 * 
+                 *
                  * We do this instead of throwing directly since this may be on
                  * a different thread and the latch is still waiting.
                  */
@@ -467,7 +467,7 @@ public void onNext(final T item) {
 
         return returnItem.get();
     }
-    
+
     /**
      * Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.
      */
@@ -486,20 +486,20 @@ public void onError(Throwable e) {
                 error[0] = e;
                 cdl.countDown();
             }
-            
+
             @Override
             public void onCompleted() {
                 cdl.countDown();
             }
         });
-        
+
         BlockingUtils.awaitForComplete(cdl, s);
         Throwable e = error[0];
         if (e != null) {
             Exceptions.propagate(e);
         }
     }
-    
+
     /**
      * Subscribes to the source and calls back the Observer methods on the current thread.
      * @param observer the observer to call event methods on
@@ -508,7 +508,7 @@ public void onCompleted() {
     public void subscribe(Observer<? super T> observer) {
         final NotificationLite<T> nl = NotificationLite.instance();
         final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();
-        
+
         @SuppressWarnings("unchecked")
         Subscription s = ((Observable<T>)o).subscribe(new Subscriber<T>() {
             @Override
@@ -524,7 +524,7 @@ public void onCompleted() {
                 queue.offer(nl.completed());
             }
         });
-        
+
         try {
             for (;;) {
                 Object o = queue.poll();
@@ -542,7 +542,7 @@ public void onCompleted() {
             s.unsubscribe();
         }
     }
-    
+
     /**
      * Subscribes to the source and calls the Subscriber methods on the current thread.
      * <p>
@@ -554,8 +554,8 @@ public void onCompleted() {
     public void subscribe(Subscriber<? super T> subscriber) {
         final NotificationLite<T> nl = NotificationLite.instance();
         final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();
-        final Producer[] theProducer = { null }; 
-        
+        final Producer[] theProducer = { null };
+
         Subscriber<T> s = new Subscriber<T>() {
             @Override
             public void onNext(T t) {
@@ -569,19 +569,19 @@ public void onError(Throwable e) {
             public void onCompleted() {
                 queue.offer(nl.completed());
             }
-            
+
             @Override
             public void setProducer(Producer p) {
                 theProducer[0] = p;
                 queue.offer(SET_PRODUCER);
             }
-            
+
             @Override
             public void onStart() {
                 queue.offer(ON_START);
             }
         };
-        
+
         subscriber.add(s);
         subscriber.add(Subscriptions.create(new Action0() {
             @Override
@@ -589,9 +589,9 @@ public void call() {
                 queue.offer(UNSUBSCRIBE);
             }
         }));
-        
+
         ((Observable<T>)o).subscribe(s);
-        
+
         try {
             for (;;) {
                 if (subscriber.isUnsubscribed()) {
@@ -621,14 +621,14 @@ public void call() {
             s.unsubscribe();
         }
     }
-    
+
     /**
      * Subscribes to the source and calls the given action on the current thread and rethrows any exception wrapped
      * into OnErrorNotImplementedException.
-     * 
+     *
      * <p>The difference between this method and {@link #forEach(Action1)} is that the
      * action is always executed on the current thread.
-     * 
+     *
      * @param onNext the callback action for each source value
      * @see #forEach(Action1)
      */
@@ -641,7 +641,7 @@ public void call(Throwable t) {
             }
         }, Actions.empty());
     }
-    
+
     /**
      * Subscribes to the source and calls the given actions on the current thread.
      * @param onNext the callback action for each source value
@@ -651,7 +651,7 @@ public void call(Throwable t) {
     public void subscribe(final Action1<? super T> onNext, final Action1<? super Throwable> onError) {
         subscribe(onNext, onError, Actions.empty());
     }
-    
+
     /**
      * Subscribes to the source and calls the given actions on the current thread.
      * @param onNext the callback action for each source value
@@ -665,12 +665,12 @@ public void subscribe(final Action1<? super T> onNext, final Action1<? super Thr
             public void onNext(T t) {
                 onNext.call(t);
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 onError.call(e);
             }
-            
+
             @Override
             public void onCompleted() {
                 onCompleted.call();
diff --git a/src/main/java/rx/observables/ConnectableObservable.java b/src/main/java/rx/observables/ConnectableObservable.java
index fe78ae55cd..7df7823d0d 100644
--- a/src/main/java/rx/observables/ConnectableObservable.java
+++ b/src/main/java/rx/observables/ConnectableObservable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -27,7 +27,7 @@
  * before the {@code Observable} begins emitting items.
  * <p>
  * <img width="640" height="510" src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/publishConnect.png" alt="">
- * 
+ *
  * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Connectable-Observable-Operators">RxJava Wiki:
  *      Connectable Observable Operators</a>
  * @param <T>
@@ -72,18 +72,18 @@ public void call(Subscription t1) {
     /**
      * Returns an {@code Observable} that stays connected to this {@code ConnectableObservable} as long as there
      * is at least one subscription to this {@code ConnectableObservable}.
-     * 
+     *
      * @return a {@link Observable}
      * @see <a href="http://reactivex.io/documentation/operators/refcount.html">ReactiveX documentation: RefCount</a>
      */
     public Observable<T> refCount() {
         return create(new OnSubscribeRefCount<T>(this));
     }
-    
+
     /**
      * Returns an Observable that automatically connects to this ConnectableObservable
      * when the first Subscriber subscribes.
-     * 
+     *
      * @return an Observable that automatically connects to this ConnectableObservable
      *         when the first Subscriber subscribes
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
@@ -95,7 +95,7 @@ public Observable<T> autoConnect() {
     /**
      * Returns an Observable that automatically connects to this ConnectableObservable
      * when the specified number of Subscribers subscribe to it.
-     * 
+     *
      * @param numberOfSubscribers the number of subscribers to await before calling connect
      *                            on the ConnectableObservable. A non-positive value indicates
      *                            an immediate connection.
@@ -107,19 +107,19 @@ public Observable<T> autoConnect() {
     public Observable<T> autoConnect(int numberOfSubscribers) {
         return autoConnect(numberOfSubscribers, Actions.empty());
     }
-    
+
     /**
      * Returns an Observable that automatically connects to this ConnectableObservable
-     * when the specified number of Subscribers subscribe to it and calls the 
+     * when the specified number of Subscribers subscribe to it and calls the
      * specified callback with the Subscription associated with the established connection.
-     * 
+     *
      * @param numberOfSubscribers the number of subscribers to await before calling connect
      *                            on the ConnectableObservable. A non-positive value indicates
      *                            an immediate connection.
      * @param connection the callback Action1 that will receive the Subscription representing the
      *                   established connection
      * @return an Observable that automatically connects to this ConnectableObservable
-     *         when the specified number of Subscribers subscribe to it and calls the 
+     *         when the specified number of Subscribers subscribe to it and calls the
      *         specified callback with the Subscription associated with the established connection
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
diff --git a/src/main/java/rx/observables/GroupedObservable.java b/src/main/java/rx/observables/GroupedObservable.java
index 98b5a3e836..c68a0526f3 100644
--- a/src/main/java/rx/observables/GroupedObservable.java
+++ b/src/main/java/rx/observables/GroupedObservable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -27,7 +27,7 @@
  * is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those
  * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they
  * may discard their buffers by applying an operator like {@link Observable#take take}{@code (0)} to them.
- * 
+ *
  * @param <K>
  *            the type of the key
  * @param <T>
@@ -40,7 +40,7 @@ public class GroupedObservable<K, T> extends Observable<T> {
 
     /**
      * Converts an {@link Observable} into a {@code GroupedObservable} with a particular key.
-     * 
+     *
      * @param <K> the key type
      * @param <T> the value type
      * @param key
@@ -77,7 +77,7 @@ public void call(Subscriber<? super T> s) {
      * <dt><b>Scheduler:</b></dt>
      * <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     * 
+     *
      * @param <K>
      *            the type of the key
      * @param <T>
@@ -99,7 +99,7 @@ protected GroupedObservable(K key, OnSubscribe<T> onSubscribe) {
 
     /**
      * Returns the key that identifies the group of items emitted by this {@code GroupedObservable}
-     * 
+     *
      * @return the key that the items emitted by this {@code GroupedObservable} were grouped by
      */
     public K getKey() {
diff --git a/src/main/java/rx/observables/SyncOnSubscribe.java b/src/main/java/rx/observables/SyncOnSubscribe.java
index 2cbcba438e..bebf6fe789 100644
--- a/src/main/java/rx/observables/SyncOnSubscribe.java
+++ b/src/main/java/rx/observables/SyncOnSubscribe.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -41,14 +41,14 @@
  */
 @Beta
 public abstract class SyncOnSubscribe<S, T> implements OnSubscribe<T> {
-    
+
     /* (non-Javadoc)
      * @see rx.functions.Action1#call(java.lang.Object)
      */
     @Override
     public final void call(final Subscriber<? super T> subscriber) {
         S state;
-        
+
         try {
             state = generateState();
         } catch (Throwable e) {
@@ -56,7 +56,7 @@ public final void call(final Subscriber<? super T> subscriber) {
             subscriber.onError(e);
             return;
         }
-        
+
         SubscriptionProducer<S, T> p = new SubscriptionProducer<S, T>(subscriber, this, state);
         subscriber.add(p);
         subscriber.setProducer(p);
@@ -67,7 +67,7 @@ public final void call(final Subscriber<? super T> subscriber) {
      * to produce a state value. This value is passed into {@link #next(Object, Observer) next(S
      * state, Observer <T> observer)} on the first iteration. Subsequent iterations of {@code next}
      * will receive the state returned by the previous invocation of {@code next}.
-     * 
+     *
      * @return the initial state value
      */
     protected abstract S generateState();
@@ -76,17 +76,17 @@ public final void call(final Subscriber<? super T> subscriber) {
      * Called to produce data to the downstream subscribers. To emit data to a downstream subscriber
      * call {@code observer.onNext(t)}. To signal an error condition call
      * {@code observer.onError(throwable)} or throw an Exception. To signal the end of a data stream
-     * call {@code 
+     * call {@code
      * observer.onCompleted()}. Implementations of this method must follow the following rules.
-     * 
+     *
      * <ul>
      * <li>Must not call {@code observer.onNext(t)} more than 1 time per invocation.</li>
      * <li>Must not call {@code observer.onNext(t)} concurrently.</li>
      * </ul>
-     * 
+     *
      * The value returned from an invocation of this method will be passed in as the {@code state}
      * argument of the next invocation of this method.
-     * 
+     *
      * @param state
      *            the state value (from {@link #generateState()} on the first invocation or the
      *            previous invocation of this method.
@@ -99,7 +99,7 @@ public final void call(final Subscriber<? super T> subscriber) {
     /**
      * Clean up behavior that is executed after the downstream subscriber's subscription is
      * unsubscribed. This method will be invoked exactly once.
-     * 
+     *
      * @param state
      *            the last state value prior from {@link #generateState()} or
      *            {@link #next(Object, Observer) next(S, Observer&lt;T&gt;)} before unsubscribe.
@@ -111,7 +111,7 @@ protected void onUnsubscribe(S state) {
     /**
      * Generates a synchronous {@link SyncOnSubscribe} that calls the provided {@code next} function
      * to generate data to downstream subscribers.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param <S> the type of the associated state with each Subscriber
      * @param generator
@@ -122,7 +122,7 @@ protected void onUnsubscribe(S state) {
      * @return a SyncOnSubscribe that emits data in a protocol compatible with back-pressure.
      */
     @Beta
-    public static <S, T> SyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator, 
+    public static <S, T> SyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator,
             final Action2<? super S, ? super Observer<? super T>> next) {
         Func2<S, ? super Observer<? super T>, S> nextFunc = new Func2<S, Observer<? super T>, S>() {
             @Override
@@ -137,9 +137,9 @@ public S call(S state, Observer<? super T> subscriber) {
     /**
      * Generates a synchronous {@link SyncOnSubscribe} that calls the provided {@code next} function
      * to generate data to downstream subscribers.
-     * 
+     *
      * This overload creates a SyncOnSubscribe without an explicit clean up step.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param <S> the type of the associated state with each Subscriber
      * @param generator
@@ -153,8 +153,8 @@ public S call(S state, Observer<? super T> subscriber) {
      *         back-pressure.
      */
     @Beta
-    public static <S, T> SyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator, 
-            final Action2<? super S, ? super Observer<? super T>> next, 
+    public static <S, T> SyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator,
+            final Action2<? super S, ? super Observer<? super T>> next,
             final Action1<? super S> onUnsubscribe) {
         Func2<S, Observer<? super T>, S> nextFunc = new Func2<S, Observer<? super T>, S>() {
             @Override
@@ -169,7 +169,7 @@ public S call(S state, Observer<? super T> subscriber) {
     /**
      * Generates a synchronous {@link SyncOnSubscribe} that calls the provided {@code next} function
      * to generate data to downstream subscribers.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param <S> the type of the associated state with each Subscriber
      * @param generator
@@ -183,16 +183,16 @@ public S call(S state, Observer<? super T> subscriber) {
      *         back-pressure.
      */
     @Beta
-    public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator, 
-            Func2<? super S, ? super Observer<? super T>, ? extends S> next, 
+    public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator,
+            Func2<? super S, ? super Observer<? super T>, ? extends S> next,
             Action1<? super S> onUnsubscribe) {
         return new SyncOnSubscribeImpl<S, T>(generator, next, onUnsubscribe);
     }
-    
+
     /**
      * Generates a synchronous {@link SyncOnSubscribe} that calls the provided {@code next} function
      * to generate data to downstream subscribers.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param <S> the type of the associated state with each Subscriber
      * @param generator
@@ -204,7 +204,7 @@ public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> gen
      *         back-pressure.
      */
     @Beta
-    public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator, 
+    public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator,
             Func2<? super S, ? super Observer<? super T>, ? extends S> next) {
         return new SyncOnSubscribeImpl<S, T>(generator, next);
     }
@@ -212,10 +212,10 @@ public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> gen
     /**
      * Generates a synchronous {@link SyncOnSubscribe} that calls the provided {@code next} function
      * to generate data to downstream subscribers.
-     * 
+     *
      * This overload creates a "state-less" SyncOnSubscribe which does not have an explicit state
      * value. This should be used when the {@code next} function closes over it's state.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param next
      *            produces data to the downstream subscriber (see {@link #next(Object, Observer)
@@ -238,10 +238,10 @@ public Void call(Void state, Observer<? super T> subscriber) {
     /**
      * Generates a synchronous {@link SyncOnSubscribe} that calls the provided {@code next} function
      * to generate data to downstream subscribers.
-     * 
+     *
      * This overload creates a "state-less" SyncOnSubscribe which does not have an explicit state
      * value. This should be used when the {@code next} function closes over it's state.
-     * 
+     *
      * @param <T> the type of the generated values
      * @param next
      *            produces data to the downstream subscriber (see {@link #next(Object, Observer)
@@ -252,7 +252,7 @@ public Void call(Void state, Observer<? super T> subscriber) {
      *         back-pressure.
      */
     @Beta
-    public static <T> SyncOnSubscribe<Void, T> createStateless(final Action1<? super Observer<? super T>> next, 
+    public static <T> SyncOnSubscribe<Void, T> createStateless(final Action1<? super Observer<? super T>> next,
             final Action0 onUnsubscribe) {
         Func2<Void, Observer<? super T>, Void> nextFunc = new Func2<Void, Observer<? super T>, Void>() {
             @Override
@@ -326,7 +326,7 @@ protected void onUnsubscribe(S state) {
      * @param <T>
      *            the type of compatible Subscribers
      */
-    static final class SubscriptionProducer<S, T> 
+    static final class SubscriptionProducer<S, T>
     extends AtomicLong implements Producer, Subscription, Observer<T> {
         /** */
         private static final long serialVersionUID = -3736864024352728072L;
@@ -334,7 +334,7 @@ static final class SubscriptionProducer<S, T>
         private final SyncOnSubscribe<S, T> parent;
         private boolean onNextCalled;
         private boolean hasTerminated;
-        
+
         private S state;
 
         SubscriptionProducer(final Subscriber<? super T> subscriber, SyncOnSubscribe<S, T> parent, S state) {
@@ -347,7 +347,7 @@ static final class SubscriptionProducer<S, T>
         public boolean isUnsubscribed() {
             return get() < 0L;
         }
-        
+
         @Override
         public void unsubscribe() {
             while(true) {
@@ -364,7 +364,7 @@ else if (compareAndSet(requestCount, -2L)) {
                 }
             }
         }
-        
+
         private boolean tryUnsubscribe() {
             // only one thread at a time can iterate over request count
             // therefore the requestCount atomic cannot be decrement concurrently here
@@ -400,7 +400,7 @@ public void request(long n) {
         private void fastpath() {
             final SyncOnSubscribe<S, T> p = parent;
             Subscriber<? super T> a = actualSubscriber;
-            
+
             for (;;) {
                 try {
                     onNextCalled = false;
@@ -458,7 +458,7 @@ private void slowPath(long n) {
         private void nextIteration(final SyncOnSubscribe<S, T> parent) {
             state = parent.next(state, this);
         }
-        
+
         @Override
         public void onCompleted() {
             if (hasTerminated) {
@@ -491,5 +491,5 @@ public void onNext(T value) {
         }
     }
 
-    
+
 }
\ No newline at end of file
diff --git a/src/main/java/rx/observers/AsyncCompletableSubscriber.java b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
index 3b9547b301..2aa9421de1 100644
--- a/src/main/java/rx/observers/AsyncCompletableSubscriber.java
+++ b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -31,7 +31,7 @@
  * <p>
  * Override the {@link #onStart()} method to execute custom logic on the very first successful onSubscribe call.
  * <p>
- * If one wants to remain consistent regarding {@link #isUnsubscribed()} and being terminated, 
+ * If one wants to remain consistent regarding {@link #isUnsubscribed()} and being terminated,
  * the {@link #clear()} method should be called from the implementing onError and onCompleted methods.
  * <p>
  * <pre><code>
@@ -40,13 +40,13 @@
  *     public void onStart() {
  *         System.out.println("Started!");
  *     }
- *     
+ *
  *     &#64;Override
  *     public void onCompleted() {
  *         System.out.println("Completed!");
  *         clear();
  *     }
- *     
+ *
  *     &#64;Override
  *     public void onError(Throwable e) {
  *         e.printStackTrace();
@@ -63,12 +63,12 @@ public abstract class AsyncCompletableSubscriber implements CompletableSubscribe
      */
     static final Unsubscribed UNSUBSCRIBED = new Unsubscribed();
 
-    /** 
+    /**
      * Holds onto a deferred subscription and allows asynchronous cancellation before the call
-     * to onSubscribe() by the upstream. 
+     * to onSubscribe() by the upstream.
      */
     private final AtomicReference<Subscription> upstream = new AtomicReference<Subscription>();
-    
+
     @Override
     public final void onSubscribe(Subscription d) {
         if (!upstream.compareAndSet(null, d)) {
@@ -80,26 +80,26 @@ public final void onSubscribe(Subscription d) {
             onStart();
         }
     }
-    
+
     /**
      * Called before the first onSubscribe() call succeeds.
      */
     protected void onStart() {
         // default behavior is no op
     }
-    
+
     @Override
     public final boolean isUnsubscribed() {
         return upstream.get() == UNSUBSCRIBED;
     }
-    
+
     /**
      * Call to clear the upstream's subscription without unsubscribing it.
      */
     protected final void clear() {
         upstream.set(UNSUBSCRIBED);
     }
-    
+
     @Override
     public final void unsubscribe() {
         Subscription current = upstream.get();
@@ -109,9 +109,9 @@ public final void unsubscribe() {
                 current.unsubscribe();
             }
         }
-        
+
     }
-    
+
     static final class Unsubscribed implements Subscription {
 
         @Override
@@ -123,6 +123,6 @@ public void unsubscribe() {
         public boolean isUnsubscribed() {
             return true;
         }
-        
+
     }
 }
diff --git a/src/main/java/rx/observers/Observers.java b/src/main/java/rx/observers/Observers.java
index 0fdb4fcc01..1fe078920d 100644
--- a/src/main/java/rx/observers/Observers.java
+++ b/src/main/java/rx/observers/Observers.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -60,7 +60,7 @@ public static <T> Observer<T> empty() {
 
     /**
      * Creates an {@link Observer} that receives the emissions of any {@code Observable} it subscribes to via
-     * {@link Observer#onNext onNext} but ignores {@link Observer#onCompleted onCompleted} notifications; 
+     * {@link Observer#onNext onNext} but ignores {@link Observer#onCompleted onCompleted} notifications;
      * it will throw an {@link OnErrorNotImplementedException} if {@link Observer#onError onError} is invoked.
      *
      * @param <T> the observed value type
@@ -100,7 +100,7 @@ public final void onNext(T args) {
      * Creates an {@link Observer} that receives the emissions of any {@code Observable} it subscribes to via
      * {@link Observer#onNext onNext} and handles any {@link Observer#onError onError} notification but ignores
      * an {@link Observer#onCompleted onCompleted} notification.
-     * 
+     *
      * @param <T> the observed value type
      * @param onNext
      *          a function that handles each item emitted by an {@code Observable}
@@ -144,7 +144,7 @@ public final void onNext(T args) {
      * Creates an {@link Observer} that receives the emissions of any {@code Observable} it subscribes to via
      * {@link Observer#onNext onNext} and handles any {@link Observer#onError onError} or
      * {@link Observer#onCompleted onCompleted} notifications.
-     * 
+     *
      * @param <T> the observed value type
      * @param onNext
      *          a function that handles each item emitted by an {@code Observable}
diff --git a/src/main/java/rx/observers/SafeCompletableSubscriber.java b/src/main/java/rx/observers/SafeCompletableSubscriber.java
index cac72dd2b5..bc7b35e858 100644
--- a/src/main/java/rx/observers/SafeCompletableSubscriber.java
+++ b/src/main/java/rx/observers/SafeCompletableSubscriber.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -24,7 +24,7 @@
 /**
  * Wraps another CompletableSubscriber and handles exceptions thrown
  * from onError and onCompleted.
- * 
+ *
  * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
  */
 @Experimental
@@ -32,9 +32,9 @@ public final class SafeCompletableSubscriber implements CompletableSubscriber, S
     final CompletableSubscriber actual;
 
     Subscription s;
-    
+
     boolean done;
-    
+
     public SafeCompletableSubscriber(CompletableSubscriber actual) {
         this.actual = actual;
     }
@@ -49,7 +49,7 @@ public void onCompleted() {
             actual.onCompleted();
         } catch (Throwable ex) {
             Exceptions.throwIfFatal(ex);
-            
+
             throw new OnCompletedFailedException(ex);
         }
     }
@@ -65,7 +65,7 @@ public void onError(Throwable e) {
             actual.onError(e);
         } catch (Throwable ex) {
             Exceptions.throwIfFatal(ex);
-            
+
             throw new OnErrorFailedException(new CompositeException(e, ex));
         }
     }
@@ -81,12 +81,12 @@ public void onSubscribe(Subscription d) {
             onError(ex);
         }
     }
-    
+
     @Override
     public void unsubscribe() {
         s.unsubscribe();
     }
-    
+
     @Override
     public boolean isUnsubscribed() {
         return done || s.isUnsubscribed();
diff --git a/src/main/java/rx/observers/SafeSubscriber.java b/src/main/java/rx/observers/SafeSubscriber.java
index b7bc17120b..75dab2f020 100644
--- a/src/main/java/rx/observers/SafeSubscriber.java
+++ b/src/main/java/rx/observers/SafeSubscriber.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -51,7 +51,7 @@
  * </ul>
  * {@code SafeSubscriber} will not synchronize {@code onNext} execution. Use {@link SerializedSubscriber} to do
  * that.
- * 
+ *
  * @param <T>
  *            the type of item expected by the {@link Subscriber}
  */
@@ -83,7 +83,7 @@ public void onCompleted() {
                 Exceptions.throwIfFatal(e);
                 RxJavaHooks.onError(e);
                 throw new OnCompletedFailedException(e.getMessage(), e);
-            } finally { // NOPMD 
+            } finally { // NOPMD
                 try {
                     // Similarly to onError if failure occurs in unsubscribe then Rx contract is broken
                     // and we throw an UnsubscribeFailureException.
@@ -101,7 +101,7 @@ public void onCompleted() {
      * <p>
      * If the {@code Observable} calls this method, it will not thereafter call {@link #onNext} or
      * {@link #onCompleted}.
-     * 
+     *
      * @param e
      *          the exception encountered by the Observable
      */
@@ -123,7 +123,7 @@ public void onError(Throwable e) {
      * <p>
      * The {@code Observable} will not call this method again after it calls either {@link #onCompleted} or
      * {@link #onError}.
-     * 
+     *
      * @param args
      *          the item emitted by the Observable
      */
@@ -143,21 +143,21 @@ public void onNext(T args) {
     /**
      * The logic for {@code onError} without the {@code isFinished} check so it can be called from within
      * {@code onCompleted}.
-     * 
+     *
      * @see <a href="https://github.com/ReactiveX/RxJava/issues/630">the report of this bug</a>
      */
-    protected void _onError(Throwable e) { // NOPMD 
+    protected void _onError(Throwable e) { // NOPMD
         RxJavaHooks.onError(e);
         try {
             actual.onError(e);
-        } catch (OnErrorNotImplementedException e2) { // NOPMD 
+        } catch (OnErrorNotImplementedException e2) { // NOPMD
             /*
              * onError isn't implemented so throw
-             * 
+             *
              * https://github.com/ReactiveX/RxJava/issues/198
-             * 
+             *
              * Rx Design Guidelines 5.2
-             * 
+             *
              * "when calling the Subscribe method that only has an onNext argument, the OnError behavior
              * will be to rethrow the exception on the thread that the message comes out from the observable
              * sequence. The OnCompleted behavior in this case is to do nothing."
@@ -166,13 +166,13 @@ protected void _onError(Throwable e) { // NOPMD
                 unsubscribe();
             } catch (Throwable unsubscribeException) {
                 RxJavaHooks.onError(unsubscribeException);
-                throw new OnErrorNotImplementedException("Observer.onError not implemented and error while unsubscribing.", new CompositeException(Arrays.asList(e, unsubscribeException))); // NOPMD 
+                throw new OnErrorNotImplementedException("Observer.onError not implemented and error while unsubscribing.", new CompositeException(Arrays.asList(e, unsubscribeException))); // NOPMD
             }
             throw e2;
         } catch (Throwable e2) {
             /*
              * throw since the Rx contract is broken if onError failed
-             * 
+             *
              * https://github.com/ReactiveX/RxJava/issues/198
              */
             RxJavaHooks.onError(e2);
diff --git a/src/main/java/rx/observers/SerializedObserver.java b/src/main/java/rx/observers/SerializedObserver.java
index 1629efe85f..bf3c44a623 100644
--- a/src/main/java/rx/observers/SerializedObserver.java
+++ b/src/main/java/rx/observers/SerializedObserver.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -29,7 +29,7 @@
  * <li>Adding notifications to a queue if another thread is already emitting</li>
  * <li>Not holding any locks or blocking any threads while emitting</li>
  * </ul>
- * 
+ *
  * @param <T>
  *          the type of items expected to be observed by the {@code Observer}
  */
@@ -123,7 +123,7 @@ public void onNext(T t) {
             }
         }
     }
-    
+
     @Override
     public void onError(final Throwable e) {
         Exceptions.throwIfFatal(e);
@@ -136,9 +136,9 @@ public void onError(final Throwable e) {
             }
             terminated = true;
             if (emitting) {
-                /* 
-                 * FIXME: generally, errors jump the queue but this wasn't true 
-                 * for SerializedObserver and may break existing expectations. 
+                /*
+                 * FIXME: generally, errors jump the queue but this wasn't true
+                 * for SerializedObserver and may break existing expectations.
                  */
                 FastList list = queue;
                 if (list == null) {
diff --git a/src/main/java/rx/observers/SerializedSubscriber.java b/src/main/java/rx/observers/SerializedSubscriber.java
index e5d05f24a2..b4ee838acc 100644
--- a/src/main/java/rx/observers/SerializedSubscriber.java
+++ b/src/main/java/rx/observers/SerializedSubscriber.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -27,7 +27,7 @@
  * <li>Adding notifications to a queue if another thread is already emitting</li>
  * <li>Not holding any locks or blocking any threads while emitting</li>
  * </ul>
- * 
+ *
  * @param <T>
  *          the type of items expected to be emitted to the {@code Subscriber}
  */
@@ -69,7 +69,7 @@ public void onCompleted() {
      * <p>
      * If the {@code Observable} calls this method, it will not thereafter call {@link #onNext} or
      * {@link #onCompleted}.
-     * 
+     *
      * @param e
      *          the exception encountered by the Observable
      */
@@ -85,7 +85,7 @@ public void onError(Throwable e) {
      * <p>
      * The {@code Observable} will not call this method again after it calls either {@link #onCompleted} or
      * {@link #onError}.
-     * 
+     *
      * @param t
      *          the item emitted by the Observable
      */
diff --git a/src/main/java/rx/observers/Subscribers.java b/src/main/java/rx/observers/Subscribers.java
index 1fd99e3f1c..28176f87e0 100644
--- a/src/main/java/rx/observers/Subscribers.java
+++ b/src/main/java/rx/observers/Subscribers.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -28,8 +28,8 @@ private Subscribers() {
     }
 
     /**
-     * Returns an inert {@link Subscriber} that does nothing in response to the emissions or notifications 
-     * from any {@code Observable} it subscribes to.  Will throw an {@link OnErrorNotImplementedException} if {@link Subscriber#onError onError} 
+     * Returns an inert {@link Subscriber} that does nothing in response to the emissions or notifications
+     * from any {@code Observable} it subscribes to.  Will throw an {@link OnErrorNotImplementedException} if {@link Subscriber#onError onError}
      * method is called
      *
      * @param <T> the observed value type
@@ -110,7 +110,7 @@ public final void onNext(T args) {
      * Creates an {@link Subscriber} that receives the emissions of any {@code Observable} it subscribes to via
      * {@link Subscriber#onNext onNext} and handles any {@link Subscriber#onError onError} notification but
      * ignores an {@link Subscriber#onCompleted onCompleted} notification.
-     * 
+     *
      * @param <T> the observed value type
      * @param onNext
      *          a function that handles each item emitted by an {@code Observable}
@@ -154,7 +154,7 @@ public final void onNext(T args) {
      * Creates an {@link Subscriber} that receives the emissions of any {@code Observable} it subscribes to via
      * {@link Subscriber#onNext onNext} and handles any {@link Subscriber#onError onError} or
      * {@link Subscriber#onCompleted onCompleted} notifications.
-     * 
+     *
      * @param <T> the observed value type
      * @param onNext
      *          a function that handles each item emitted by an {@code Observable}
@@ -206,11 +206,11 @@ public final void onNext(T args) {
      * <code>subscriber</code> and uses the subscription list of
      * <code>subscriber</code> when {@link Subscriber#add(rx.Subscription)} is
      * called.
-     * 
+     *
      * @param <T> the observed value type
      * @param subscriber
      *            the Subscriber to wrap.
-     * 
+     *
      * @return a new Subscriber that passes all events to
      *         <code>subscriber</code>, has backpressure controlled by
      *         <code>subscriber</code> and uses <code>subscriber</code> to
@@ -234,7 +234,7 @@ public void onError(Throwable e) {
             public void onNext(T t) {
                 subscriber.onNext(t);
             }
-            
+
         };
     }
 }
diff --git a/src/main/java/rx/observers/TestObserver.java b/src/main/java/rx/observers/TestObserver.java
index b46cbd8941..bcfc5f9131 100644
--- a/src/main/java/rx/observers/TestObserver.java
+++ b/src/main/java/rx/observers/TestObserver.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -132,8 +132,8 @@ public void assertReceivedOnNext(List<T> items) {
                     assertionError("Value at index: " + i + " expected to be [null] but was: [" + actual + "]\n");
                 }
             } else if (!expected.equals(actual)) {
-                assertionError("Value at index: " + i 
-                        + " expected to be [" + expected + "] (" + expected.getClass().getSimpleName() 
+                assertionError("Value at index: " + i
+                        + " expected to be [" + expected + "] (" + expected.getClass().getSimpleName()
                         + ") but was: [" + actual + "] (" + (actual != null ? actual.getClass().getSimpleName() : "null") + ")\n");
 
             }
@@ -172,10 +172,10 @@ public void assertTerminalEvent() {
      */
     final void assertionError(String message) {
         StringBuilder b = new StringBuilder(message.length() + 32);
-        
+
         b.append(message)
         .append(" (");
-        
+
         int c = onCompletedEvents.size();
         b.append(c)
         .append(" completion");
@@ -183,7 +183,7 @@ final void assertionError(String message) {
             b.append('s');
         }
         b.append(')');
-        
+
         if (!onErrorEvents.isEmpty()) {
             int size = onErrorEvents.size();
             b.append(" (+")
@@ -194,7 +194,7 @@ final void assertionError(String message) {
             }
             b.append(')');
         }
-        
+
         AssertionError ae = new AssertionError(b.toString());
         if (!onErrorEvents.isEmpty()) {
             if (onErrorEvents.size() == 1) {
@@ -205,7 +205,7 @@ final void assertionError(String message) {
         }
         throw ae;
     }
-    
+
     // do nothing ... including swallowing errors
     private static final Observer<Object> INERT = new Observer<Object>() {
 
@@ -223,6 +223,6 @@ public void onError(Throwable e) {
         public void onNext(Object t) {
              // deliberately ignored
         }
-        
+
     };
 }
diff --git a/src/main/java/rx/observers/TestSubscriber.java b/src/main/java/rx/observers/TestSubscriber.java
index 1dcf336091..cfa1f74ef9 100644
--- a/src/main/java/rx/observers/TestSubscriber.java
+++ b/src/main/java/rx/observers/TestSubscriber.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -31,19 +31,19 @@
 public class TestSubscriber<T> extends Subscriber<T> {
 
     private final Observer<T> delegate;
-    
+
     private final List<T> values;
-    
+
     private final List<Throwable> errors;
-    
+
     /** The number of onCompleted() calls. */
     private int completions;
-    
+
     private final CountDownLatch latch = new CountDownLatch(1);
-    
+
     /** Written after an onNext value has been added to the {@link #values} list. */
     private volatile int valueCount;
-    
+
     private volatile Thread lastSeenThread;
     /** The shared no-op observer. */
     private static final Observer<Object> INERT = new Observer<Object>() {
@@ -75,7 +75,7 @@ public void onNext(Object t) {
     public TestSubscriber(long initialRequest) {
         this((Observer<T>)INERT, initialRequest);
     }
-    
+
     /**
      * Constructs a TestSubscriber with the initial request to be requested from upstream
      * and a delegate Observer to wrap.
@@ -93,7 +93,7 @@ public TestSubscriber(Observer<T> delegate, long initialRequest) {
         if (initialRequest >= 0L) {
             this.request(initialRequest);
         }
-        
+
         this.values = new ArrayList<T>();
         this.errors = new ArrayList<Throwable>();
     }
@@ -136,7 +136,7 @@ public TestSubscriber() {
     public static <T> TestSubscriber<T> create() {
         return new TestSubscriber<T>();
     }
-    
+
     /**
      * Factory method to construct a TestSubscriber with the given initial request amount and no delegation.
      * @param <T> the value type
@@ -147,7 +147,7 @@ public static <T> TestSubscriber<T> create() {
     public static <T> TestSubscriber<T> create(long initialRequest) {
         return new TestSubscriber<T>(initialRequest);
     }
-    
+
     /**
      * Factory method to construct a TestSubscriber which delegates events to the given Observer and
      * issues the given initial request amount.
@@ -174,7 +174,7 @@ public static <T> TestSubscriber<T> create(Observer<T> delegate, long initialReq
     public static <T> TestSubscriber<T> create(Subscriber<T> delegate) {
         return new TestSubscriber<T>(delegate);
     }
-    
+
     /**
      * Factory method to construct a TestSubscriber which delegates events to the given Observer and
      * an issues an initial request of Long.MAX_VALUE.
@@ -187,7 +187,7 @@ public static <T> TestSubscriber<T> create(Subscriber<T> delegate) {
     public static <T> TestSubscriber<T> create(Observer<T> delegate) {
         return new TestSubscriber<T>(delegate);
     }
-    
+
     /**
      * Notifies the Subscriber that the {@code Observable} has finished sending push-based notifications.
      * <p>
@@ -209,7 +209,7 @@ public void onCompleted() {
      * completion via {@link #onCompleted}, as a {@link List}.
      *
      * @return a list of Notifications representing calls to this Subscriber's {@link #onCompleted} method
-     * 
+     *
      * @deprecated use {@link #getCompletions()} instead.
      */
     @Deprecated
@@ -221,7 +221,7 @@ public List<Notification<T>> getOnCompletedEvents() {
         }
         return result;
     }
-    
+
     /**
      * Returns the number of times onCompleted was called on this TestSubscriber.
      * @return the number of times onCompleted was called on this TestSubscriber.
@@ -237,7 +237,7 @@ public final int getCompletions() {
      * <p>
      * If the {@code Observable} calls this method, it will not thereafter call {@link #onNext} or
      * {@link #onCompleted}.
-     * 
+     *
      * @param e
      *          the exception encountered by the Observable
      */
@@ -269,7 +269,7 @@ public List<Throwable> getOnErrorEvents() {
      * <p>
      * The {@code Observable} will not call this method again after it calls either {@link #onCompleted} or
      * {@link #onError}.
-     * 
+     *
      * @param t
      *          the item emitted by the Observable
      */
@@ -280,7 +280,7 @@ public void onNext(T t) {
         valueCount = values.size();
         delegate.onNext(t);
     }
-    
+
     /**
      * Returns the committed number of onNext elements that are safe to be
      * read from {@link #getOnNextEvents()} other threads.
@@ -289,7 +289,7 @@ public void onNext(T t) {
     public final int getValueCount() {
         return valueCount;
     }
-    
+
     /**
      * Allows calling the protected {@link #request(long)} from unit tests.
      *
@@ -331,7 +331,7 @@ public void assertReceivedOnNext(List<T> items) {
             assertItem(items.get(i), i);
         }
     }
-    
+
     private void assertItem(T expected, int i) {
         T actual = values.get(i);
         if (expected == null) {
@@ -340,8 +340,8 @@ private void assertItem(T expected, int i) {
                 assertionError("Value at index: " + i + " expected to be [null] but was: [" + actual + "]\n");
             }
         } else if (!expected.equals(actual)) {
-            assertionError("Value at index: " + i 
-                    + " expected to be [" + expected + "] (" + expected.getClass().getSimpleName() 
+            assertionError("Value at index: " + i
+                    + " expected to be [" + expected + "] (" + expected.getClass().getSimpleName()
                     + ") but was: [" + actual + "] (" + (actual != null ? actual.getClass().getSimpleName() : "null") + ")\n");
 
         }
@@ -370,7 +370,7 @@ public final boolean awaitValueCount(int expected, long timeout, TimeUnit unit)
         }
         return valueCount >= expected;
     }
-    
+
     /**
      * Asserts that a single terminal event occurred, either {@link #onCompleted} or {@link #onError}.
      *
@@ -409,7 +409,7 @@ public void assertUnsubscribed() {
 
     /**
      * Asserts that this {@code Subscriber} has received no {@code onError} notifications.
-     * 
+     *
      * @throws AssertionError
      *          if this {@code Subscriber} has received one or more {@code onError} notifications
      */
@@ -420,7 +420,7 @@ public void assertNoErrors() {
         }
     }
 
-    
+
     /**
      * Blocks until this {@link Subscriber} receives a notification that the {@code Observable} is complete
      * (either an {@code onCompleted} or {@code onError} notification).
@@ -488,7 +488,7 @@ public void awaitTerminalEventAndUnsubscribeOnTimeout(long timeout, TimeUnit uni
     public Thread getLastSeenThread() {
         return lastSeenThread;
     }
-    
+
     /**
      * Asserts that there is exactly one completion event.
      *
@@ -614,7 +614,7 @@ public void assertValueCount(int count) {
             assertionError("Number of onNext events differ; expected: " + count + ", actual: " + s);
         }
     }
-    
+
     /**
      * Asserts that the received onNext events, in order, are the specified items.
      *
@@ -636,7 +636,7 @@ public void assertValues(T... values) {
     public void assertValue(T value) {
         assertReceivedOnNext(Collections.singletonList(value));
     }
-    
+
     /**
      * Combines an assertion error message with the current completion and error state of this
      * TestSubscriber, giving more information when some assertXXX check fails.
@@ -644,10 +644,10 @@ public void assertValue(T value) {
      */
     final void assertionError(String message) {
         StringBuilder b = new StringBuilder(message.length() + 32);
-        
+
         b.append(message)
         .append(" (");
-        
+
         int c = completions;
         b.append(c)
         .append(" completion");
@@ -655,7 +655,7 @@ final void assertionError(String message) {
             b.append('s');
         }
         b.append(')');
-        
+
         if (!errors.isEmpty()) {
             int size = errors.size();
             b.append(" (+")
@@ -666,7 +666,7 @@ final void assertionError(String message) {
             }
             b.append(')');
         }
-        
+
         AssertionError ae = new AssertionError(b.toString());
         if (!errors.isEmpty()) {
             if (errors.size() == 1) {
@@ -677,21 +677,21 @@ final void assertionError(String message) {
         }
         throw ae;
     }
-    
+
     /**
      * Assert that the TestSubscriber contains the given first and optional rest values exactly
      * and if so, clears the internal list of values.
      * <p>
      * <code><pre>
      * TestSubscriber ts = new TestSubscriber();
-     * 
+     *
      * ts.onNext(1);
-     * 
+     *
      * ts.assertValuesAndClear(1);
-     * 
+     *
      * ts.onNext(2);
      * ts.onNext(3);
-     * 
+     *
      * ts.assertValuesAndClear(2, 3); // no mention of 1
      * </pre></code>
      * @param expectedFirstValue the expected first value
diff --git a/src/main/java/rx/package-info.java b/src/main/java/rx/package-info.java
index cae651eab2..9a3ff1a612 100644
--- a/src/main/java/rx/package-info.java
+++ b/src/main/java/rx/package-info.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -16,7 +16,7 @@
 /**
  * Base reactive classes: Observable, Single and Completable; base reactive consumers;
  * other common base interfaces.
- * 
+ *
  * <p>A library that enables subscribing to and composing asynchronous events and
  * callbacks.</p>
  * <p>The Observable/Observer interfaces and associated operators (in
@@ -26,8 +26,8 @@
  * More information can be found at <a
  * href="http://msdn.microsoft.com/en-us/data/gg577609">http://msdn.microsoft.com/en-us/data/gg577609</a>.
  * </p>
- * 
- * 
+ *
+ *
  * <p>Compared with the Microsoft implementation:
  * <ul>
  * <li>Observable == IObservable</li>
diff --git a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
index 5400ef8b63..c8303ed779 100644
--- a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
@@ -38,7 +38,7 @@
  * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
  */
 @Experimental
-public abstract class RxJavaCompletableExecutionHook { // NOPMD 
+public abstract class RxJavaCompletableExecutionHook { // NOPMD
     /**
      * Invoked during the construction by {@link Completable#create(Completable.OnSubscribe)}
      * <p>
diff --git a/src/main/java/rx/plugins/RxJavaErrorHandler.java b/src/main/java/rx/plugins/RxJavaErrorHandler.java
index f6ca781d1b..a84526e1ef 100644
--- a/src/main/java/rx/plugins/RxJavaErrorHandler.java
+++ b/src/main/java/rx/plugins/RxJavaErrorHandler.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -31,7 +31,7 @@
  * See {@link RxJavaPlugins} or the RxJava GitHub Wiki for information on configuring plugins: <a
  * href="https://github.com/ReactiveX/RxJava/wiki/Plugins">https://github.com/ReactiveX/RxJava/wiki/Plugins</a>.
  */
-public abstract class RxJavaErrorHandler { // NOPMD 
+public abstract class RxJavaErrorHandler { // NOPMD
 
     protected static final String ERROR_IN_RENDERING_SUFFIX = ".errorRendering";
 
@@ -41,7 +41,7 @@ public abstract class RxJavaErrorHandler { // NOPMD
      * <p>
      * This should <em>never</em> throw an {@code Exception}. Make sure to try/catch({@code Throwable}) all code
      * inside this method implementation.
-     * 
+     *
      * @param e
      *            the {@code Exception}
      */
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index 61ad3c69c2..ede280a1dc 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -28,7 +28,7 @@
  * points as well as Scheduler hooks.
  * <p>
  * The class features a lockdown state, see {@link #lockdown()} and {@link #isLockdown()}, to
- * prevent further changes to the hooks. 
+ * prevent further changes to the hooks.
  */
 @Experimental
 public final class RxJavaHooks {
@@ -36,9 +36,9 @@ public final class RxJavaHooks {
      * Prevents changing the hook callbacks when set to true.
      */
     /* test */ static volatile boolean lockdown;
-    
+
     static volatile Action1<Throwable> onError;
-    
+
     @SuppressWarnings("rawtypes")
     static volatile Func1<Observable.OnSubscribe, Observable.OnSubscribe> onObservableCreate;
 
@@ -60,13 +60,13 @@ public final class RxJavaHooks {
     static volatile Func1<Scheduler, Scheduler> onIOScheduler;
 
     static volatile Func1<Scheduler, Scheduler> onNewThreadScheduler;
-    
+
     static volatile Func1<Action0, Action0> onScheduleAction;
 
     static volatile Func1<Subscription, Subscription> onObservableReturn;
 
     static volatile Func1<Subscription, Subscription> onSingleReturn;
-    
+
     static volatile Func0<? extends ScheduledExecutorService> onGenericScheduledExecutorService;
 
     static volatile Func1<Throwable, Throwable> onObservableSubscribeError;
@@ -92,7 +92,7 @@ public final class RxJavaHooks {
     private RxJavaHooks() {
         throw new IllegalStateException("No instances!");
     }
-    
+
 
     /**
      * Initialize the hooks via delegating to RxJavaPlugins.
@@ -105,35 +105,35 @@ public void call(Throwable e) {
                 RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
             }
         };
-        
+
         onObservableStart = new Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe>() {
             @Override
             public Observable.OnSubscribe call(Observable t1, Observable.OnSubscribe t2) {
                 return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeStart(t1, t2);
             }
         };
-        
+
         onObservableReturn = new Func1<Subscription, Subscription>() {
             @Override
             public Subscription call(Subscription f) {
                 return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeReturn(f);
             }
         };
-        
+
         onSingleStart = new Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe>() {
             @Override
             public Observable.OnSubscribe call(Single t1, Observable.OnSubscribe t2) {
                 return RxJavaPlugins.getInstance().getSingleExecutionHook().onSubscribeStart(t1, t2);
             }
         };
-        
+
         onSingleReturn = new Func1<Subscription, Subscription>() {
             @Override
             public Subscription call(Subscription f) {
                 return RxJavaPlugins.getInstance().getSingleExecutionHook().onSubscribeReturn(f);
             }
         };
-        
+
         onCompletableStart = new Func2<Completable, Completable.OnSubscribe, Completable.OnSubscribe>() {
             @Override
             public Completable.OnSubscribe call(Completable t1, Completable.OnSubscribe t2) {
@@ -147,14 +147,14 @@ public Action0 call(Action0 a) {
                 return RxJavaPlugins.getInstance().getSchedulersHook().onSchedule(a);
             }
         };
-        
+
         onObservableSubscribeError = new Func1<Throwable, Throwable>() {
             @Override
             public Throwable call(Throwable t) {
                 return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeError(t);
             }
         };
-        
+
         onObservableLift = new Func1<Observable.Operator, Observable.Operator>() {
             @Override
             public Observable.Operator call(Observable.Operator t) {
@@ -168,7 +168,7 @@ public Throwable call(Throwable t) {
                 return RxJavaPlugins.getInstance().getSingleExecutionHook().onSubscribeError(t);
             }
         };
-        
+
         onSingleLift = new Func1<Observable.Operator, Observable.Operator>() {
             @Override
             public Observable.Operator call(Observable.Operator t) {
@@ -182,7 +182,7 @@ public Throwable call(Throwable t) {
                 return RxJavaPlugins.getInstance().getCompletableExecutionHook().onSubscribeError(t);
             }
         };
-        
+
         onCompletableLift = new Func1<Completable.Operator, Completable.Operator>() {
             @Override
             public Completable.Operator call(Completable.Operator t) {
@@ -192,7 +192,7 @@ public Completable.Operator call(Completable.Operator t) {
 
         initCreate();
     }
-    
+
     @SuppressWarnings({ "rawtypes", "unchecked", "deprecation" })
     static void initCreate() {
         onObservableCreate = new Func1<Observable.OnSubscribe, Observable.OnSubscribe>() {
@@ -216,10 +216,10 @@ public Completable.OnSubscribe call(Completable.OnSubscribe f) {
             }
         };
     }
-    
+
     /**
      * Reset all hook callbacks to those of the current RxJavaPlugins handlers.
-     * 
+     *
      * @see #clear()
      */
     public static void reset() {
@@ -227,7 +227,7 @@ public static void reset() {
             return;
         }
         init();
-        
+
         onComputationScheduler = null;
         onIOScheduler = null;
         onNewThreadScheduler = null;
@@ -238,7 +238,7 @@ public static void reset() {
      * Clears all hooks to be no-operations (and passthroughs)
      * and onError hook to signal errors to the caller thread's
      * UncaughtExceptionHandler.
-     * 
+     *
      * @see #reset()
      */
     public static void clear() {
@@ -246,24 +246,24 @@ public static void clear() {
             return;
         }
         onError = null;
-        
+
         onObservableCreate = null;
         onObservableStart = null;
         onObservableReturn = null;
         onObservableSubscribeError = null;
         onObservableLift = null;
-        
+
         onSingleCreate = null;
         onSingleStart = null;
         onSingleReturn = null;
         onSingleSubscribeError = null;
         onSingleLift = null;
-        
+
         onCompletableCreate = null;
         onCompletableStart = null;
         onCompletableSubscribeError = null;
         onCompletableLift = null;
-        
+
         onComputationScheduler = null;
         onIOScheduler = null;
         onNewThreadScheduler = null;
@@ -278,7 +278,7 @@ public static void clear() {
     public static void lockdown() {
         lockdown = true;
     }
-    
+
     /**
      * Returns true if the hooks can no longer be changed.
      * @return true if the hooks can no longer be changed
@@ -302,21 +302,21 @@ public static void onError(Throwable ex) {
                  * Since the plugin should never throw this is a safety net
                  * and will complain loudly to System.err so it gets fixed.
                  */
-                System.err.println("The onError handler threw an Exception. It shouldn't. => " + pluginException.getMessage()); // NOPMD 
+                System.err.println("The onError handler threw an Exception. It shouldn't. => " + pluginException.getMessage()); // NOPMD
                 pluginException.printStackTrace(); // NOPMD
-                
+
                 signalUncaught(pluginException);
             }
         }
         signalUncaught(ex);
     }
-    
+
     static void signalUncaught(Throwable ex) {
         Thread current = Thread.currentThread();
         UncaughtExceptionHandler handler = current.getUncaughtExceptionHandler();
         handler.uncaughtException(current, ex);
     }
-    
+
     /**
      * Hook to call when an Observable is created.
      * @param <T> the value type
@@ -359,11 +359,11 @@ public static Completable.OnSubscribe onCreate(Completable.OnSubscribe onSubscri
         }
         return onSubscribe;
     }
-    
+
     /**
      * Hook to call when the Schedulers.computation() is called.
      * @param scheduler the default computation scheduler
-     * @return the default of alternative scheduler 
+     * @return the default of alternative scheduler
      */
     public static Scheduler onComputationScheduler(Scheduler scheduler) {
         Func1<Scheduler, Scheduler> f = onComputationScheduler;
@@ -376,7 +376,7 @@ public static Scheduler onComputationScheduler(Scheduler scheduler) {
     /**
      * Hook to call when the Schedulers.io() is called.
      * @param scheduler the default io scheduler
-     * @return the default of alternative scheduler 
+     * @return the default of alternative scheduler
      */
     public static Scheduler onIOScheduler(Scheduler scheduler) {
         Func1<Scheduler, Scheduler> f = onIOScheduler;
@@ -389,7 +389,7 @@ public static Scheduler onIOScheduler(Scheduler scheduler) {
     /**
      * Hook to call when the Schedulers.newThread() is called.
      * @param scheduler the default new thread scheduler
-     * @return the default of alternative scheduler 
+     * @return the default of alternative scheduler
      */
     public static Scheduler onNewThreadScheduler(Scheduler scheduler) {
         Func1<Scheduler, Scheduler> f = onNewThreadScheduler;
@@ -428,7 +428,7 @@ public static <T> Observable.OnSubscribe<T> onObservableStart(Observable<T> inst
         }
         return onSubscribe;
     }
-    
+
     /**
      * Hook to call before the Observable.subscribe() method is about to return a Subscription.
      * @param subscription the original subscription
@@ -572,7 +572,7 @@ public static <T, R> Completable.Operator onCompletableLift(Completable.Operator
         return operator;
     }
 
-    
+
     /**
      * Sets the global error consumer action unless a lockdown is in effect.
      * <p>
@@ -588,7 +588,7 @@ public static void setOnError(Action1<Throwable> onError) {
         }
         RxJavaHooks.onError = onError;
     }
-    
+
     /**
      * Sets the Completable's onCreate hook function unless a lockdown is in effect.
      * <p>
@@ -606,7 +606,7 @@ public static void setOnCompletableCreate(
         }
         RxJavaHooks.onCompletableCreate = onCompletableCreate;
     }
-    
+
     /**
      * Sets the Observable onCreate hook function unless a lockdown is in effect.
      * <p>
@@ -625,7 +625,7 @@ public static void setOnObservableCreate(
         }
         RxJavaHooks.onObservableCreate = onObservableCreate;
     }
-    
+
     /**
      * Sets the Single onCreate hook function unless a lockdown is in effect.
      * <p>
@@ -643,7 +643,7 @@ public static void setOnSingleCreate(Func1<Single.OnSubscribe, Single.OnSubscrib
         }
         RxJavaHooks.onSingleCreate = onSingleCreate;
     }
-    
+
     /**
      * Sets the hook function for returning a scheduler when the Schedulers.computation() is called
      * unless a lockdown is in effect.
@@ -661,7 +661,7 @@ public static void setOnComputationScheduler(Func1<Scheduler, Scheduler> onCompu
         }
         RxJavaHooks.onComputationScheduler = onComputationScheduler;
     }
-    
+
     /**
      * Sets the hook function for returning a scheduler when the Schedulers.io() is called
      * unless a lockdown is in effect.
@@ -679,7 +679,7 @@ public static void setOnIOScheduler(Func1<Scheduler, Scheduler> onIOScheduler) {
         }
         RxJavaHooks.onIOScheduler = onIOScheduler;
     }
-    
+
     /**
      * Sets the hook function for returning a scheduler when the Schedulers.newThread() is called
      * unless a lockdown is in effect.
@@ -697,7 +697,7 @@ public static void setOnNewThreadScheduler(Func1<Scheduler, Scheduler> onNewThre
         }
         RxJavaHooks.onNewThreadScheduler = onNewThreadScheduler;
     }
-    
+
     /**
      * Sets the hook function that is called before an action is scheduled, allowing
      * decorating that function, unless a lockdown is in effect.
@@ -715,7 +715,7 @@ public static void setOnScheduleAction(Func1<Action0, Action0> onScheduleAction)
         }
         RxJavaHooks.onScheduleAction = onScheduleAction;
     }
-    
+
     /**
      * Sets the hook function that is called when a subscriber subscribes to a Completable
      * unless a lockdown is in effect.
@@ -735,7 +735,7 @@ public static void setOnCompletableStart(
         }
         RxJavaHooks.onCompletableStart = onCompletableStart;
     }
-    
+
     /**
      * Sets the hook function that is called when a subscriber subscribes to a Observable
      * unless a lockdown is in effect.
@@ -756,7 +756,7 @@ public static void setOnObservableStart(
         }
         RxJavaHooks.onObservableStart = onObservableStart;
     }
-    
+
     /**
      * Sets the hook function that is called when a subscriber subscribes to a Single
      * unless a lockdown is in effect.
@@ -776,9 +776,9 @@ public static void setOnSingleStart(Func2<Single, Observable.OnSubscribe, Observ
         }
         RxJavaHooks.onSingleStart = onSingleStart;
     }
-    
+
     /**
-     * Sets a hook function that is called when the Observable.subscribe() call 
+     * Sets a hook function that is called when the Observable.subscribe() call
      * is about to return a Subscription unless a lockdown is in effect.
      * <p>
      * This operation is threadsafe.
@@ -795,9 +795,9 @@ public static void setOnObservableReturn(Func1<Subscription, Subscription> onObs
         }
         RxJavaHooks.onObservableReturn = onObservableReturn;
     }
-    
+
     /**
-     * Sets a hook function that is called when the Single.subscribe() call 
+     * Sets a hook function that is called when the Single.subscribe() call
      * is about to return a Subscription unless a lockdown is in effect.
      * <p>
      * This operation is threadsafe.
@@ -843,7 +843,7 @@ public static void setOnSingleSubscribeError(Func1<Throwable, Throwable> onSingl
     public static Func1<Throwable, Throwable> getOnSingleSubscribeError() {
         return onSingleSubscribeError;
     }
-    
+
     /**
      * Sets a hook function that is called when the Completable.subscribe() call
      * fails with an exception.
@@ -872,7 +872,7 @@ public static void setOnCompletableSubscribeError(Func1<Throwable, Throwable> on
     public static Func1<Throwable, Throwable> getOnCompletableSubscribeError() {
         return onCompletableSubscribeError;
     }
-    
+
     /**
      * Sets a hook function that is called when the Observable.subscribe() call
      * fails with an exception.
@@ -901,7 +901,7 @@ public static void setOnObservableSubscribeError(Func1<Throwable, Throwable> onO
     public static Func1<Throwable, Throwable> getOnObservableSubscribeError() {
         return onObservableSubscribeError;
     }
-    
+
     /**
      * Sets a hook function that is called with an operator when an Observable operator built with
      * lift() gets subscribed to.
@@ -920,7 +920,7 @@ public static void setOnObservableLift(Func1<Observable.Operator, Observable.Ope
         }
         RxJavaHooks.onObservableLift = onObservableLift;
     }
-    
+
     /**
      * Returns the current Observable onLift hook function or null if it is
      * set to the default pass-through.
@@ -951,7 +951,7 @@ public static void setOnSingleLift(Func1<Observable.Operator, Observable.Operato
         }
         RxJavaHooks.onSingleLift = onSingleLift;
     }
-    
+
     /**
      * Returns the current Single onLift hook function or null if it is
      * set to the default pass-through.
@@ -981,7 +981,7 @@ public static void setOnCompletableLift(Func1<Completable.Operator, Completable.
         }
         RxJavaHooks.onCompletableLift = onCompletableLift;
     }
-    
+
     /**
      * Returns the current Completable onLift hook function or null if it is
      * set to the default pass-through.
@@ -1003,7 +1003,7 @@ public static Func1<Completable.Operator, Completable.Operator> getOnCompletable
     public static Func1<Scheduler, Scheduler> getOnComputationScheduler() {
         return onComputationScheduler;
     }
-    
+
     /**
      * Returns the current global error handler hook action or null if it is
      * set to the default one that signals errors to the current threads
@@ -1015,7 +1015,7 @@ public static Func1<Scheduler, Scheduler> getOnComputationScheduler() {
     public static Action1<Throwable> getOnError() {
         return onError;
     }
-    
+
     /**
      * Returns the current io scheduler hook function or null if it is
      * set to the default pass-through.
@@ -1026,7 +1026,7 @@ public static Action1<Throwable> getOnError() {
     public static Func1<Scheduler, Scheduler> getOnIOScheduler() {
         return onIOScheduler;
     }
-    
+
     /**
      * Returns the current new thread scheduler hook function or null if it is
      * set to the default pass-through.
@@ -1037,7 +1037,7 @@ public static Func1<Scheduler, Scheduler> getOnIOScheduler() {
     public static Func1<Scheduler, Scheduler> getOnNewThreadScheduler() {
         return onNewThreadScheduler;
     }
-    
+
     /**
      * Returns the current Observable onCreate hook function or null if it is
      * set to the default pass-through.
@@ -1049,7 +1049,7 @@ public static Func1<Scheduler, Scheduler> getOnNewThreadScheduler() {
     public static Func1<Observable.OnSubscribe, Observable.OnSubscribe> getOnObservableCreate() {
         return onObservableCreate;
     }
-    
+
     /**
      * Returns the current schedule action hook function or null if it is
      * set to the default pass-through.
@@ -1060,7 +1060,7 @@ public static Func1<Observable.OnSubscribe, Observable.OnSubscribe> getOnObserva
     public static Func1<Action0, Action0> getOnScheduleAction() {
         return onScheduleAction;
     }
-    
+
     /**
      * Returns the current Single onCreate hook function or null if it is
      * set to the default pass-through.
@@ -1072,7 +1072,7 @@ public static Func1<Action0, Action0> getOnScheduleAction() {
     public static Func1<Single.OnSubscribe, Single.OnSubscribe> getOnSingleCreate() {
         return onSingleCreate;
     }
-    
+
     /**
      * Returns the current Completable onCreate hook function or null if it is
      * set to the default pass-through.
@@ -1083,7 +1083,7 @@ public static Func1<Single.OnSubscribe, Single.OnSubscribe> getOnSingleCreate()
     public static Func1<Completable.OnSubscribe, Completable.OnSubscribe> getOnCompletableCreate() {
         return onCompletableCreate;
     }
-    
+
     /**
      * Returns the current Completable onStart hook function or null if it is
      * set to the default pass-through.
@@ -1094,7 +1094,7 @@ public static Func1<Completable.OnSubscribe, Completable.OnSubscribe> getOnCompl
     public static Func2<Completable, Completable.OnSubscribe, Completable.OnSubscribe> getOnCompletableStart() {
         return onCompletableStart;
     }
-    
+
     /**
      * Returns the current Observable onStart hook function or null if it is
      * set to the default pass-through.
@@ -1106,7 +1106,7 @@ public static Func2<Completable, Completable.OnSubscribe, Completable.OnSubscrib
     public static Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> getOnObservableStart() {
         return onObservableStart;
     }
-    
+
     /**
      * Returns the current Single onStart hook function or null if it is
      * set to the default pass-through.
@@ -1118,7 +1118,7 @@ public static Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe>
     public static Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> getOnSingleStart() {
         return onSingleStart;
     }
-    
+
     /**
      * Returns the current Observable onReturn hook function or null if it is
      * set to the default pass-through.
@@ -1129,7 +1129,7 @@ public static Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> getO
     public static Func1<Subscription, Subscription> getOnObservableReturn() {
         return onObservableReturn;
     }
-    
+
     /**
      * Returns the current Single onReturn hook function or null if it is
      * set to the default pass-through.
@@ -1175,7 +1175,7 @@ public static void enableAssemblyTracking() {
         if (lockdown) {
             return;
         }
-        
+
         onObservableCreate = new Func1<Observable.OnSubscribe, Observable.OnSubscribe>() {
             @Override
             public Observable.OnSubscribe call(Observable.OnSubscribe f) {
@@ -1217,7 +1217,7 @@ public static void setOnGenericScheduledExecutorService(Func0<? extends Schedule
         }
         onGenericScheduledExecutorService = factory;
     }
-    
+
     /**
      * Returns the current factory for creating ScheduledExecutorServices in
      * GenericScheduledExecutorService utility.
diff --git a/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index 7996e1f3e9..f1b897fa21 100644
--- a/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -37,15 +37,15 @@
  * Methods are also invoked synchronously and will add to execution time of the observable so all behavior
  * should be fast. If anything time-consuming is to be done it should be spawned asynchronously onto separate
  * worker threads.
- * 
+ *
  */
-public abstract class RxJavaObservableExecutionHook { // NOPMD 
+public abstract class RxJavaObservableExecutionHook { // NOPMD
     /**
      * Invoked during the construction by {@link Observable#create(OnSubscribe)}
      * <p>
      * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
      * logging, metrics and other such things and pass through the function.
-     * 
+     *
      * @param <T> the value type
      * @param f
      *            original {@link OnSubscribe}<{@code T}> to be executed
@@ -62,7 +62,7 @@ public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
      * <p>
      * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
      * logging, metrics and other such things and pass through the function.
-     * 
+     *
      * @param <T> the value type
      * @param observableInstance the parent observable instance
      * @param onSubscribe
@@ -82,7 +82,7 @@ public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableIns
      * <p>
      * This can be used to decorate or replace the {@link Subscription} instance or just perform extra logging,
      * metrics and other such things and pass through the subscription.
-     * 
+     *
      * @param <T> the value type
      * @param subscription
      *            original {@link Subscription}
@@ -100,7 +100,7 @@ public <T> Subscription onSubscribeReturn(Subscription subscription) {
      * <p>
      * This is <em>not</em> errors emitted via {@link Subscriber#onError(Throwable)} but exceptions thrown when
      * attempting to subscribe to a {@link Func1}<{@link Subscriber}{@code <T>}, {@link Subscription}>.
-     * 
+     *
      * @param <T> the value type
      * @param e
      *            Throwable thrown by {@link Observable#subscribe(Subscriber)}
@@ -118,7 +118,7 @@ public <T> Throwable onSubscribeError(Throwable e) {
      * <p>
      * This can be used to decorate or replace the {@link Operator} instance or just perform extra
      * logging, metrics and other such things and pass through the onSubscribe.
-     * 
+     *
      * @param <T> the upstream's value type (input)
      * @param <R> the downstream's value type (output)
      * @param lift
diff --git a/src/main/java/rx/plugins/RxJavaObservableExecutionHookDefault.java b/src/main/java/rx/plugins/RxJavaObservableExecutionHookDefault.java
index f8cfa5e4f5..2bc2a788aa 100644
--- a/src/main/java/rx/plugins/RxJavaObservableExecutionHookDefault.java
+++ b/src/main/java/rx/plugins/RxJavaObservableExecutionHookDefault.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -24,9 +24,9 @@
 
     /** Utility class. */
     private RxJavaObservableExecutionHookDefault() {
-        
+
     }
-    
+
     public static RxJavaObservableExecutionHook getInstance() {
         return INSTANCE;
     }
diff --git a/src/main/java/rx/plugins/RxJavaPlugins.java b/src/main/java/rx/plugins/RxJavaPlugins.java
index cc846fd6e1..f9df704304 100644
--- a/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -34,7 +34,7 @@
  * rxjava.plugin.[index].class}
  * rxjava.plugin.[index].impl}
  * </code></pre>
- * 
+ *
  * Where the {@code .class} property contains the simple classname from above and the {@code .impl}
  * contains the fully qualified name of the implementation class. The {@code [index]} can be
  * any short string or number of your choosing. For example, you can now define a custom
@@ -43,9 +43,9 @@
  * rxjava.plugin.1.class=RxJavaErrorHandler
  * rxjava.plugin.1.impl=some.package.MyRxJavaErrorHandler
  * </code></pre>
- * 
+ *
  * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Plugins">RxJava Wiki: Plugins</a>
- * 
+ *
  * Use the {@link RxJavaHooks} features instead which let's you change individual
  * handlers at runtime.
  */
@@ -65,7 +65,7 @@ public class RxJavaPlugins {
      * Retrieves the single {@code RxJavaPlugins} instance.
      *
      * @return the single {@code RxJavaPlugins} instance
-     * 
+     *
      * @deprecated use the static methods of {@link RxJavaHooks}.
      */
     @Deprecated
@@ -76,12 +76,12 @@ public static RxJavaPlugins getInstance() {
     /* package accessible for unit tests */RxJavaPlugins() {
         // nothing to do
     }
-    
+
     /**
      * Reset {@code RxJavaPlugins} instance
      * <p>
-     * This API is experimental. Resetting the plugins is dangerous 
-     * during application runtime and also bad code could invoke it in 
+     * This API is experimental. Resetting the plugins is dangerous
+     * during application runtime and also bad code could invoke it in
      * the middle of an application life-cycle and really break applications
      * if not used cautiously. For more detailed discussions:
      * * @see <a href="https://github.com/ReactiveX/RxJava/issues/2297">Make RxJavaPlugins.reset() public</a>
@@ -108,7 +108,7 @@ public RxJavaErrorHandler getErrorHandler() {
             // check for an implementation from System.getProperty first
             Object impl = getPluginImplementationViaProperty(RxJavaErrorHandler.class, System.getProperties());
             if (impl == null) {
-                // nothing set via properties so initialize with default 
+                // nothing set via properties so initialize with default
                 errorHandler.compareAndSet(null, DEFAULT_ERROR_HANDLER);
                 // we don't return from here but call get() again in case of thread-race so the winner will always get returned
             } else {
@@ -122,7 +122,7 @@ public RxJavaErrorHandler getErrorHandler() {
     /**
      * Registers an {@link RxJavaErrorHandler} implementation as a global override of any injected or default
      * implementations.
-     * 
+     *
      * @param impl
      *            {@link RxJavaErrorHandler} implementation
      * @throws IllegalStateException
@@ -142,7 +142,7 @@ public void registerErrorHandler(RxJavaErrorHandler impl) {
      * Override the default by calling {@link #registerObservableExecutionHook(RxJavaObservableExecutionHook)}
      * or by setting the property {@code rxjava.plugin.RxJavaObservableExecutionHook.implementation} with the
      * full classname to load.
-     * 
+     *
      * @return {@link RxJavaObservableExecutionHook} implementation to use
      */
     public RxJavaObservableExecutionHook getObservableExecutionHook() {
@@ -150,7 +150,7 @@ public RxJavaObservableExecutionHook getObservableExecutionHook() {
             // check for an implementation from System.getProperty first
             Object impl = getPluginImplementationViaProperty(RxJavaObservableExecutionHook.class, System.getProperties());
             if (impl == null) {
-                // nothing set via properties so initialize with default 
+                // nothing set via properties so initialize with default
                 observableExecutionHook.compareAndSet(null, RxJavaObservableExecutionHookDefault.getInstance());
                 // we don't return from here but call get() again in case of thread-race so the winner will always get returned
             } else {
@@ -164,7 +164,7 @@ public RxJavaObservableExecutionHook getObservableExecutionHook() {
     /**
      * Register an {@link RxJavaObservableExecutionHook} implementation as a global override of any injected or
      * default implementations.
-     * 
+     *
      * @param impl
      *            {@link RxJavaObservableExecutionHook} implementation
      * @throws IllegalStateException
@@ -269,7 +269,7 @@ public void registerCompletableExecutionHook(RxJavaCompletableExecutionHook impl
         // Make a defensive clone because traversal may fail with ConcurrentModificationException
         // if the properties get changed by something outside RxJava.
         Properties props = (Properties)propsIn.clone();
-        
+
         final String classSimpleName = pluginClass.getSimpleName();
         /*
          * Check system properties for plugin class.
@@ -277,32 +277,32 @@ public void registerCompletableExecutionHook(RxJavaCompletableExecutionHook impl
          * This will only happen during system startup thus it's okay to use the synchronized
          * System.getProperties as it will never get called in normal operations.
          */
-        
+
         String pluginPrefix = "rxjava.plugin.";
-        
+
         String defaultKey = pluginPrefix + classSimpleName + ".implementation";
         String implementingClass = props.getProperty(defaultKey);
 
         if (implementingClass == null) {
             String classSuffix = ".class";
             String implSuffix = ".impl";
-    
+
             for (Map.Entry<Object, Object> e : props.entrySet()) {
                 String key = e.getKey().toString();
                 if (key.startsWith(pluginPrefix) && key.endsWith(classSuffix)) {
                     String value = e.getValue().toString();
-                    
+
                     if (classSimpleName.equals(value)) {
                         String index = key.substring(0, key.length() - classSuffix.length()).substring(pluginPrefix.length());
-                        
+
                         String implKey = pluginPrefix + index + implSuffix;
-                        
+
                         implementingClass = props.getProperty(implKey);
-                        
+
                         if (implementingClass == null) {
                             throw new IllegalStateException("Implementing class declaration for " + classSimpleName + " missing: " + implKey);
                         }
-                        
+
                         break;
                     }
                 }
diff --git a/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java b/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
index 809a968f6b..ad3d3bfc85 100644
--- a/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaSingleExecutionHook.java
@@ -38,7 +38,7 @@
  * worker threads.
  *
  */
-public abstract class RxJavaSingleExecutionHook { // NOPMD 
+public abstract class RxJavaSingleExecutionHook { // NOPMD
     /**
      * Invoked during the construction by {@link Single#create(Single.OnSubscribe)}
      * <p>
diff --git a/src/main/java/rx/plugins/RxJavaSingleExecutionHookDefault.java b/src/main/java/rx/plugins/RxJavaSingleExecutionHookDefault.java
index dd09ecfc79..d84eff34cc 100644
--- a/src/main/java/rx/plugins/RxJavaSingleExecutionHookDefault.java
+++ b/src/main/java/rx/plugins/RxJavaSingleExecutionHookDefault.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -27,7 +27,7 @@ final class RxJavaSingleExecutionHookDefault extends RxJavaSingleExecutionHook {
      */
     private RxJavaSingleExecutionHookDefault() {
     }
-    
+
     public static RxJavaSingleExecutionHook getInstance() {
         return INSTANCE;
     }
diff --git a/src/main/java/rx/schedulers/ImmediateScheduler.java b/src/main/java/rx/schedulers/ImmediateScheduler.java
index 2a4cc4d823..728dce77f5 100644
--- a/src/main/java/rx/schedulers/ImmediateScheduler.java
+++ b/src/main/java/rx/schedulers/ImmediateScheduler.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -22,7 +22,7 @@
  */
 @Deprecated
 // Class was part of public API.
-public final class ImmediateScheduler extends Scheduler { // NOPMD 
+public final class ImmediateScheduler extends Scheduler { // NOPMD
     private ImmediateScheduler() {
         throw new IllegalStateException("No instances!");
     }
diff --git a/src/main/java/rx/schedulers/NewThreadScheduler.java b/src/main/java/rx/schedulers/NewThreadScheduler.java
index c17165ddde..7834d5499f 100644
--- a/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -22,7 +22,7 @@
  */
 @Deprecated
 // Class was part of public API.
-public final class NewThreadScheduler extends Scheduler { // NOPMD 
+public final class NewThreadScheduler extends Scheduler { // NOPMD
     private NewThreadScheduler() {
         throw new IllegalStateException("No instances!");
     }
diff --git a/src/main/java/rx/schedulers/Schedulers.java b/src/main/java/rx/schedulers/Schedulers.java
index 8df2dacf99..32857181a9 100644
--- a/src/main/java/rx/schedulers/Schedulers.java
+++ b/src/main/java/rx/schedulers/Schedulers.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -146,7 +146,7 @@ public static Scheduler io() {
      *
      * @return a {@code TestScheduler} meant for debugging
      */
-    public static TestScheduler test() { // NOPMD 
+    public static TestScheduler test() { // NOPMD
         return new TestScheduler();
     }
 
@@ -173,21 +173,21 @@ public static void reset() {
             s.shutdownInstance();
         }
     }
-    
+
     /**
      * Starts those standard Schedulers which support the SchedulerLifecycle interface.
      * <p>The operation is idempotent and threadsafe.
      */
     public static void start() {
         Schedulers s = getInstance();
-        
+
         s.startInstance();
-        
+
         synchronized (s) {
             GenericScheduledExecutorService.INSTANCE.start();
-            
+
             RxRingBuffer.SPSC_POOL.start();
-            
+
             RxRingBuffer.SPMC_POOL.start();
         }
     }
@@ -201,17 +201,17 @@ public static void shutdown() {
 
         synchronized (s) {
             GenericScheduledExecutorService.INSTANCE.shutdown();
-            
+
             RxRingBuffer.SPSC_POOL.shutdown();
 
             RxRingBuffer.SPMC_POOL.shutdown();
         }
     }
-    
+
     /**
      * Start the instance-specific schedulers.
      */
-    synchronized void startInstance() { // NOPMD 
+    synchronized void startInstance() { // NOPMD
         if (computationScheduler instanceof SchedulerLifecycle) {
             ((SchedulerLifecycle) computationScheduler).start();
         }
@@ -222,11 +222,11 @@ synchronized void startInstance() { // NOPMD
             ((SchedulerLifecycle) newThreadScheduler).start();
         }
     }
-    
+
     /**
      * Start the instance-specific schedulers.
      */
-    synchronized void shutdownInstance() { // NOPMD 
+    synchronized void shutdownInstance() { // NOPMD
         if (computationScheduler instanceof SchedulerLifecycle) {
             ((SchedulerLifecycle) computationScheduler).shutdown();
         }
diff --git a/src/main/java/rx/schedulers/TestScheduler.java b/src/main/java/rx/schedulers/TestScheduler.java
index b4d3b6e9af..f540569b19 100644
--- a/src/main/java/rx/schedulers/TestScheduler.java
+++ b/src/main/java/rx/schedulers/TestScheduler.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -32,9 +32,9 @@
  */
 public class TestScheduler extends Scheduler {
     final Queue<TimedAction> queue = new PriorityQueue<TimedAction>(11, new CompareActionsByTime());
-    
+
     static long counter;
-    
+
     // Storing time in nanoseconds internally.
     long time;
 
diff --git a/src/main/java/rx/schedulers/TimeInterval.java b/src/main/java/rx/schedulers/TimeInterval.java
index b5e7760c3d..d8065b677f 100644
--- a/src/main/java/rx/schedulers/TimeInterval.java
+++ b/src/main/java/rx/schedulers/TimeInterval.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -42,7 +42,7 @@ public TimeInterval(long intervalInMilliseconds, T value) {
 
     /**
      * Returns the time interval, expressed in milliseconds.
-     * 
+     *
      * @return the time interval in milliseconds
      */
     public long getIntervalInMilliseconds() {
diff --git a/src/main/java/rx/schedulers/Timestamped.java b/src/main/java/rx/schedulers/Timestamped.java
index cce5c210ff..e05f21d226 100644
--- a/src/main/java/rx/schedulers/Timestamped.java
+++ b/src/main/java/rx/schedulers/Timestamped.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -30,7 +30,7 @@ public Timestamped(long timestampMillis, T value) {
 
     /**
      * Returns the timestamp, expressed in milliseconds.
-     * 
+     *
      * @return timestamp in milliseconds
      */
     public long getTimestampMillis() {
@@ -39,7 +39,7 @@ public long getTimestampMillis() {
 
     /**
      * Returns the value embedded in the {@code Timestamped} object.
-     * 
+     *
      * @return the value
      */
     public T getValue() {
diff --git a/src/main/java/rx/schedulers/TrampolineScheduler.java b/src/main/java/rx/schedulers/TrampolineScheduler.java
index 48fb332e54..4a7edc2edd 100644
--- a/src/main/java/rx/schedulers/TrampolineScheduler.java
+++ b/src/main/java/rx/schedulers/TrampolineScheduler.java
@@ -22,7 +22,7 @@
  */
 @Deprecated
 // Class was part of public API.
-public final class TrampolineScheduler extends Scheduler { // NOPMD 
+public final class TrampolineScheduler extends Scheduler { // NOPMD
     private TrampolineScheduler() {
         throw new IllegalStateException("No instances!");
     }
diff --git a/src/main/java/rx/schedulers/package-info.java b/src/main/java/rx/schedulers/package-info.java
index 7dc59c5083..d9e76afba0 100644
--- a/src/main/java/rx/schedulers/package-info.java
+++ b/src/main/java/rx/schedulers/package-info.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 /**
- * Scheduler implementations, value+time record classes and the standard factory class to 
+ * Scheduler implementations, value+time record classes and the standard factory class to
  * return standard RxJava schedulers or wrap any Executor-based (thread pool) instances.
  */
 package rx.schedulers;
\ No newline at end of file
diff --git a/src/main/java/rx/singles/BlockingSingle.java b/src/main/java/rx/singles/BlockingSingle.java
index 2c14498b87..f5d9f0027f 100644
--- a/src/main/java/rx/singles/BlockingSingle.java
+++ b/src/main/java/rx/singles/BlockingSingle.java
@@ -34,7 +34,7 @@
  * <p/>
  * You construct a {@code BlockingSingle} from a {@code Single} with {@link #from(Single)}
  * or {@link Single#toBlocking()}.
- * 
+ *
  * @param <T> the value type of the sequence
  * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
  */
diff --git a/src/main/java/rx/subjects/AsyncSubject.java b/src/main/java/rx/subjects/AsyncSubject.java
index 07a8440232..c8259c4b2c 100644
--- a/src/main/java/rx/subjects/AsyncSubject.java
+++ b/src/main/java/rx/subjects/AsyncSubject.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -53,7 +53,7 @@
   subject.onCompleted();
 
   } </pre>
- * 
+ *
  * @param <T>
  *          the type of item expected to be observed by the Subject
  */
@@ -174,7 +174,7 @@ public boolean hasCompleted() {
      * the subject hasn't terminated with an exception.
      * <p>The method can return {@code null} for various reasons. Use {@link #hasValue()}, {@link #hasThrowable()}
      * and {@link #hasCompleted()} to determine if such {@code null} is a valid value, there was an
-     * exception or the Subject terminated without receiving any value. 
+     * exception or the Subject terminated without receiving any value.
      * @return the current value or {@code null} if the Subject doesn't have a value,
      * has terminated with an exception or has an actual {@code null} as a value.
      */
diff --git a/src/main/java/rx/subjects/BehaviorSubject.java b/src/main/java/rx/subjects/BehaviorSubject.java
index 1ed4892746..5fb1f5e71b 100644
--- a/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/src/main/java/rx/subjects/BehaviorSubject.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -57,7 +57,7 @@
   subject.onNext("one");
   subject.onCompleted();
   subject.subscribe(observer);
-  
+
   // observer will receive only onError
   BehaviorSubject<Object> subject = BehaviorSubject.create("default");
   subject.onNext("zero");
@@ -65,7 +65,7 @@
   subject.onError(new RuntimeException("error"));
   subject.subscribe(observer);
   } </pre>
- * 
+ *
  * @param <T>
  *          the type of item expected to be observed by the Subject
  */
@@ -88,7 +88,7 @@ public static <T> BehaviorSubject<T> create() {
     /**
      * Creates a {@link BehaviorSubject} that emits the last item it observed and all subsequent items to each
      * {@link Observer} that subscribes to it.
-     * 
+     *
      * @param <T>
      *            the type of item the Subject will emit
      * @param defaultValue
@@ -110,10 +110,10 @@ private static <T> BehaviorSubject<T> create(T defaultValue, boolean hasDefault)
             public void call(SubjectObserver<T> o) {
                 o.emitFirst(state.getLatest(), state.nl);
             }
-            
+
         };
         state.onTerminated = state.onAdded;
-        return new BehaviorSubject<T>(state, state); 
+        return new BehaviorSubject<T>(state, state);
     }
 
     protected BehaviorSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> state) {
@@ -207,7 +207,7 @@ public boolean hasCompleted() {
      * the subject hasn't terminated yet.
      * <p>The method can return {@code null} for various reasons. Use {@link #hasValue()}, {@link #hasThrowable()}
      * and {@link #hasCompleted()} to determine if such {@code null} is a valid value, there was an
-     * exception or the Subject terminated (with or without receiving any value). 
+     * exception or the Subject terminated (with or without receiving any value).
      * @return the current value or {@code null} if the Subject doesn't have a value,
      * has terminated or has an actual {@code null} as a valid value.
      */
@@ -233,10 +233,10 @@ public Throwable getThrowable() {
         return null;
     }
     /**
-     * Returns a snapshot of the currently buffered non-terminal events into 
+     * Returns a snapshot of the currently buffered non-terminal events into
      * the provided {@code a} array or creates a new array if it has not enough capacity.
      * @param a the array to fill in
-     * @return the array {@code a} if it had enough capacity or a new array containing the available values 
+     * @return the array {@code a} if it had enough capacity or a new array containing the available values
      */
     @Beta
     @SuppressWarnings("unchecked")
@@ -256,7 +256,7 @@ public T[] getValues(T[] a) {
         }
         return a;
     }
-    
+
     /**
      * Returns a snapshot of the currently buffered non-terminal events.
      * <p>The operation is threadsafe.
diff --git a/src/main/java/rx/subjects/PublishSubject.java b/src/main/java/rx/subjects/PublishSubject.java
index 5072a3d6e7..05f89c48c9 100644
--- a/src/main/java/rx/subjects/PublishSubject.java
+++ b/src/main/java/rx/subjects/PublishSubject.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -45,7 +45,7 @@
   subject.onCompleted();
 
   } </pre>
- * 
+ *
  * @param <T>
  *          the type of items observed and emitted by the Subject
  */
@@ -62,7 +62,7 @@ public final class PublishSubject<T> extends Subject<T, T> {
     public static <T> PublishSubject<T> create() {
         return new PublishSubject<T>(new PublishSubjectState<T>());
     }
-    
+
     protected PublishSubject(PublishSubjectState<T> state) {
         super(state);
         this.state = state;
@@ -88,7 +88,7 @@ public void onCompleted() {
     public boolean hasObservers() {
         return state.get().length != 0;
     }
-    
+
     /**
      * Check if the Subject has terminated with an exception.
      * @return true if the subject has received a throwable through {@code onError}.
@@ -117,32 +117,32 @@ public Throwable getThrowable() {
         }
         return null;
     }
-    
-    static final class PublishSubjectState<T> 
+
+    static final class PublishSubjectState<T>
     extends AtomicReference<PublishSubjectProducer<T>[]>
     implements OnSubscribe<T>, Observer<T> {
 
         /** */
         private static final long serialVersionUID = -7568940796666027140L;
-        
+
         @SuppressWarnings("rawtypes")
-        static final PublishSubjectProducer[] EMPTY = new PublishSubjectProducer[0]; 
+        static final PublishSubjectProducer[] EMPTY = new PublishSubjectProducer[0];
         @SuppressWarnings("rawtypes")
-        static final PublishSubjectProducer[] TERMINATED = new PublishSubjectProducer[0]; 
-        
+        static final PublishSubjectProducer[] TERMINATED = new PublishSubjectProducer[0];
+
         Throwable error;
-        
+
         @SuppressWarnings("unchecked")
         public PublishSubjectState() {
             lazySet(EMPTY);
         }
-        
+
         @Override
         public void call(Subscriber<? super T> t) {
             PublishSubjectProducer<T> pp = new PublishSubjectProducer<T>(this, t);
             t.add(pp);
             t.setProducer(pp);
-            
+
             if (add(pp)) {
                 if (pp.isUnsubscribed()) {
                     remove(pp);
@@ -156,28 +156,28 @@ public void call(Subscriber<? super T> t) {
                 }
             }
         }
-        
-        
+
+
         boolean add(PublishSubjectProducer<T> inner) {
             for (;;) {
                 PublishSubjectProducer<T>[] curr = get();
                 if (curr == TERMINATED) {
                     return false;
                 }
-                
+
                 int n = curr.length;
-                
+
                 @SuppressWarnings("unchecked")
                 PublishSubjectProducer<T>[] next = new PublishSubjectProducer[n + 1];
                 System.arraycopy(curr, 0, next, 0, n);
-                
+
                 next[n] = inner;
                 if (compareAndSet(curr, next)) {
                     return true;
                 }
             }
         }
-        
+
         @SuppressWarnings("unchecked")
         void remove(PublishSubjectProducer<T> inner) {
             for (;;) {
@@ -185,7 +185,7 @@ void remove(PublishSubjectProducer<T> inner) {
                 if (curr == TERMINATED || curr == EMPTY) {
                     return;
                 }
-                
+
                 int n = curr.length;
                 int j = -1;
                 for (int i = 0; i < n; i++) {
@@ -194,11 +194,11 @@ void remove(PublishSubjectProducer<T> inner) {
                         break;
                     }
                 }
-                
+
                 if (j < 0) {
                     return;
                 }
-                
+
                 PublishSubjectProducer<T>[] next;
                 if (n == 1) {
                     next = EMPTY;
@@ -207,7 +207,7 @@ void remove(PublishSubjectProducer<T> inner) {
                     System.arraycopy(curr, 0, next, 0, j);
                     System.arraycopy(curr, j + 1, next, j, n - j - 1);
                 }
-                
+
                 if (compareAndSet(curr, next)) {
                     return;
                 }
@@ -236,7 +236,7 @@ public void onError(Throwable e) {
                     errors.add(ex);
                 }
             }
-            
+
             Exceptions.throwIfAny(errors);
         }
 
@@ -249,24 +249,24 @@ public void onCompleted() {
         }
 
     }
-    
-    static final class PublishSubjectProducer<T> 
+
+    static final class PublishSubjectProducer<T>
     extends AtomicLong
     implements Producer, Subscription, Observer<T> {
         /** */
         private static final long serialVersionUID = 6451806817170721536L;
 
         final PublishSubjectState<T> parent;
-        
+
         final Subscriber<? super T> actual;
-        
+
         long produced;
-        
+
         public PublishSubjectProducer(PublishSubjectState<T> parent, Subscriber<? super T> actual) {
             this.parent = parent;
             this.actual = actual;
         }
-        
+
         @Override
         public void request(long n) {
             if (BackpressureUtils.validate(n)) {
@@ -282,19 +282,19 @@ public void request(long n) {
                 }
             }
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return get() == Long.MIN_VALUE;
         }
-        
+
         @Override
         public void unsubscribe() {
             if (getAndSet(Long.MIN_VALUE) != Long.MIN_VALUE) {
                 parent.remove(this);
             }
         }
-        
+
         @Override
         public void onNext(T t) {
             long r = get();
@@ -309,14 +309,14 @@ public void onNext(T t) {
                 }
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             if (get() != Long.MIN_VALUE) {
                 actual.onError(e);
             }
         }
-        
+
         @Override
         public void onCompleted() {
             if (get() != Long.MIN_VALUE) {
diff --git a/src/main/java/rx/subjects/ReplaySubject.java b/src/main/java/rx/subjects/ReplaySubject.java
index 52dffd5752..6358872588 100644
--- a/src/main/java/rx/subjects/ReplaySubject.java
+++ b/src/main/java/rx/subjects/ReplaySubject.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -48,7 +48,7 @@
   subject.subscribe(observer2);
 
   } </pre>
- * 
+ *
  * @param <T>
  *          the type of items observed and emitted by the Subject
  */
@@ -140,7 +140,7 @@ public static <T> ReplaySubject<T> create(int capacity) {
      * discards the oldest item.
      * <p>
      * When observers subscribe to a terminated {@code ReplaySubject}, they are guaranteed to see at most
-     * {@code size} {@code onNext} events followed by a termination event. 
+     * {@code size} {@code onNext} events followed by a termination event.
      * <p>
      * If an observer subscribes while the {@code ReplaySubject} is active, it will observe all items in the
      * buffer at that point in time and each item observed afterwards, even if the buffer evicts items due to
@@ -164,10 +164,10 @@ public static <T> ReplaySubject<T> createWithSize(int size) {
      * In this setting, the {@code ReplaySubject} internally tags each observed item with a timestamp value
      * supplied by the {@link Scheduler} and keeps only those whose age is less than the supplied time value
      * converted to milliseconds. For example, an item arrives at T=0 and the max age is set to 5; at T&gt;=5
-     * this first item is then evicted by any subsequent item or termination event, leaving the buffer empty. 
+     * this first item is then evicted by any subsequent item or termination event, leaving the buffer empty.
      * <p>
      * Once the subject is terminated, observers subscribing to it will receive items that remained in the
-     * buffer after the terminal event, regardless of their age. 
+     * buffer after the terminal event, regardless of their age.
      * <p>
      * If an observer subscribes while the {@code ReplaySubject} is active, it will observe only those items
      * from within the buffer that have an age less than the specified time, and each item observed thereafter,
@@ -237,17 +237,17 @@ public static <T> ReplaySubject<T> createWithTimeAndSize(long time, TimeUnit uni
         super(state);
         this.state = state;
     }
-    
+
     @Override
     public void onNext(T t) {
         state.onNext(t);
     }
-    
+
     @Override
     public void onError(final Throwable e) {
         state.onError(e);
     }
-    
+
     @Override
     public void onCompleted() {
         state.onCompleted();
@@ -312,16 +312,16 @@ public boolean hasValue() {
         return hasAnyValue();
     }
     /**
-     * Returns a snapshot of the currently buffered non-terminal events into 
+     * Returns a snapshot of the currently buffered non-terminal events into
      * the provided {@code a} array or creates a new array if it has not enough capacity.
      * @param a the array to fill in
-     * @return the array {@code a} if it had enough capacity or a new array containing the available values 
+     * @return the array {@code a} if it had enough capacity or a new array containing the available values
      */
     @Beta
     public T[] getValues(T[] a) {
         return state.buffer.toArray(a);
     }
-    
+
     /**
      * Returns a snapshot of the currently buffered non-terminal events.
      * <p>The operation is threadsafe.
@@ -338,12 +338,12 @@ public Object[] getValues() {
         }
         return r;
     }
-    
+
     @Beta
     public T getValue() {
         return state.buffer.last();
     }
-    
+
     /**
      * Holds onto the array of Subscriber-wrapping ReplayProducers and
      * the buffer that holds values to be replayed; it manages
@@ -351,32 +351,32 @@ public T getValue() {
      *
      * @param <T> the value type
      */
-    static final class ReplayState<T> 
+    static final class ReplayState<T>
     extends AtomicReference<ReplayProducer<T>[]>
     implements OnSubscribe<T>, Observer<T> {
 
         /** */
         private static final long serialVersionUID = 5952362471246910544L;
-        
+
         final ReplayBuffer<T> buffer;
-        
+
         @SuppressWarnings("rawtypes")
         static final ReplayProducer[] EMPTY = new ReplayProducer[0];
         @SuppressWarnings("rawtypes")
         static final ReplayProducer[] TERMINATED = new ReplayProducer[0];
-        
+
         @SuppressWarnings("unchecked")
         public ReplayState(ReplayBuffer<T> buffer) {
             this.buffer = buffer;
             lazySet(EMPTY);
         }
-        
+
         @Override
         public void call(Subscriber<? super T> t) {
             ReplayProducer<T> rp = new ReplayProducer<T>(t, this);
             t.add(rp);
             t.setProducer(rp);
-            
+
             if (add(rp)) {
                 if (rp.isUnsubscribed()) {
                     remove(rp);
@@ -385,27 +385,27 @@ public void call(Subscriber<? super T> t) {
             }
             buffer.drain(rp);
         }
-        
+
         boolean add(ReplayProducer<T> rp) {
             for (;;) {
                 ReplayProducer<T>[] a = get();
                 if (a == TERMINATED) {
                     return false;
                 }
-                
+
                 int n = a.length;
-                
+
                 @SuppressWarnings("unchecked")
                 ReplayProducer<T>[] b = new ReplayProducer[n + 1];
                 System.arraycopy(a, 0, b, 0, n);
                 b[n] = rp;
-                
+
                 if (compareAndSet(a, b)) {
                     return true;
                 }
             }
         }
-        
+
         @SuppressWarnings("unchecked")
         void remove(ReplayProducer<T> rp) {
             for (;;) {
@@ -413,9 +413,9 @@ void remove(ReplayProducer<T> rp) {
                 if (a == TERMINATED || a == EMPTY) {
                     return;
                 }
-                
+
                 int n = a.length;
-                
+
                 int j = -1;
                 for (int i = 0; i < n; i++) {
                     if (a[i] == rp) {
@@ -423,11 +423,11 @@ void remove(ReplayProducer<T> rp) {
                         break;
                     }
                 }
-                
+
                 if (j < 0) {
                     return;
                 }
-                
+
                 ReplayProducer<T>[] b;
                 if (n == 1) {
                     b = EMPTY;
@@ -445,7 +445,7 @@ void remove(ReplayProducer<T> rp) {
         @Override
         public void onNext(T t) {
             ReplayBuffer<T> b = buffer;
-            
+
             b.next(t);
             for (ReplayProducer<T> rp : get()) {
                 b.drain(rp);
@@ -456,7 +456,7 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable e) {
             ReplayBuffer<T> b = buffer;
-            
+
             b.error(e);
             List<Throwable> errors = null;
             for (ReplayProducer<T> rp : getAndSet(TERMINATED)) {
@@ -469,7 +469,7 @@ public void onError(Throwable e) {
                     errors.add(ex);
                 }
             }
-            
+
             Exceptions.throwIfAny(errors);
         }
 
@@ -477,19 +477,19 @@ public void onError(Throwable e) {
         @Override
         public void onCompleted() {
             ReplayBuffer<T> b = buffer;
-            
+
             b.complete();
             for (ReplayProducer<T> rp : getAndSet(TERMINATED)) {
                 b.drain(rp);
             }
         }
-        
-        
+
+
         boolean isTerminated() {
             return get() == TERMINATED;
         }
     }
-    
+
     /**
      * The base interface for buffering signals to be replayed to individual
      * Subscribers.
@@ -497,28 +497,28 @@ boolean isTerminated() {
      * @param <T> the value type
      */
     interface ReplayBuffer<T> {
-        
+
         void next(T t);
-        
+
         void error(Throwable e);
-        
+
         void complete();
-        
+
         void drain(ReplayProducer<T> rp);
-        
+
         boolean isComplete();
-        
+
         Throwable error();
-        
+
         T last();
-        
+
         int size();
-        
+
         boolean isEmpty();
-        
+
         T[] toArray(T[] a);
     }
-    
+
     /**
      * An unbounded ReplayBuffer implementation that uses linked-arrays
      * to avoid copy-on-grow situation with ArrayList.
@@ -527,18 +527,18 @@ interface ReplayBuffer<T> {
      */
     static final class ReplayUnboundedBuffer<T> implements ReplayBuffer<T> {
         final int capacity;
-        
+
         volatile int size;
-        
+
         final Object[] head;
-        
+
         Object[] tail;
-        
+
         int tailIndex;
-        
+
         volatile boolean done;
         Throwable error;
-        
+
         public ReplayUnboundedBuffer(int capacity) {
             this.capacity = capacity;
             this.tail = this.head = new Object[capacity + 1];
@@ -562,7 +562,7 @@ public void next(T t) {
                 tailIndex = i + 1;
             }
             size++;
-            
+
         }
 
         @Override
@@ -585,30 +585,30 @@ public void drain(ReplayProducer<T> rp) {
             if (rp.getAndIncrement() != 0) {
                 return;
             }
-            
+
             int missed = 1;
-            
+
             final Subscriber<? super T> a = rp.actual;
             final int n = capacity;
-            
+
             for (;;) {
-                
+
                 long r = rp.requested.get();
                 long e = 0L;
-                
+
                 Object[] node = (Object[])rp.node;
                 if (node == null) {
                     node = head;
                 }
                 int tailIndex = rp.tailIndex;
                 int index = rp.index;
-                
+
                 while (e != r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
                         return;
                     }
-                    
+
                     boolean d = done;
                     boolean empty = index == size;
 
@@ -622,32 +622,32 @@ public void drain(ReplayProducer<T> rp) {
                         }
                         return;
                     }
-                    
+
                     if (empty) {
                         break;
                     }
-                    
+
                     if (tailIndex == n) {
                         node = (Object[])node[tailIndex];
                         tailIndex = 0;
                     }
-                    
+
                     @SuppressWarnings("unchecked")
                     T v = (T)node[tailIndex];
-                    
+
                     a.onNext(v);
-                    
+
                     e++;
                     tailIndex++;
                     index++;
                 }
-                
+
                 if (e == r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
                         return;
                     }
-                    
+
                     boolean d = done;
                     boolean empty = index == size;
 
@@ -662,17 +662,17 @@ public void drain(ReplayProducer<T> rp) {
                         return;
                     }
                 }
-                
+
                 if (e != 0L) {
                     if (r != Long.MAX_VALUE) {
                         BackpressureUtils.produced(rp.requested, e);
                     }
                 }
-                
+
                 rp.index = index;
                 rp.tailIndex = tailIndex;
                 rp.node = node;
-                
+
                 missed = rp.addAndGet(-missed);
                 if (missed == 0) {
                     return;
@@ -703,12 +703,12 @@ public T last() {
             }
             Object[] h = head;
             int n = capacity;
-            
+
             while (s >= n) {
                 h = (Object[])h[n];
                 s -= n;
             }
-            
+
             return (T)h[s - 1];
         }
 
@@ -740,29 +740,29 @@ public T[] toArray(T[] a) {
                 j += n;
                 h = (Object[])h[n];
             }
-            
+
             System.arraycopy(h, 0, a, j, s - j);
-            
+
             if (a.length > s) {
                 a[s] = null;
             }
-            
+
             return a;
         }
     }
-    
+
     static final class ReplaySizeBoundBuffer<T> implements ReplayBuffer<T> {
         final int limit;
-        
+
         volatile Node<T> head;
-        
+
         Node<T> tail;
 
         int size;
 
         volatile boolean done;
         Throwable error;
-        
+
         public ReplaySizeBoundBuffer(int limit) {
             this.limit = limit;
             Node<T> n = new Node<T>(null);
@@ -799,32 +799,32 @@ public void drain(ReplayProducer<T> rp) {
             if (rp.getAndIncrement() != 0) {
                 return;
             }
-            
+
             final Subscriber<? super T> a = rp.actual;
-            
+
             int missed = 1;
-            
+
             for (;;) {
-                
+
                 long r = rp.requested.get();
                 long e = 0L;
-                
+
                 @SuppressWarnings("unchecked")
                 Node<T> node = (Node<T>)rp.node;
                 if (node == null) {
                     node = head;
                 }
-                
+
                 while (e != r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
                         return;
                     }
-                    
+
                     boolean d = done;
                     Node<T> next = node.get();
                     boolean empty = next == null;
-                    
+
                     if (d && empty) {
                         rp.node = null;
                         Throwable ex = error;
@@ -835,26 +835,26 @@ public void drain(ReplayProducer<T> rp) {
                         }
                         return;
                     }
-                    
+
                     if (empty) {
                         break;
                     }
-                    
+
                     a.onNext(next.value);
-                    
+
                     e++;
                     node = next;
                 }
-                
+
                 if (e == r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
                         return;
                     }
-                    
+
                     boolean d = done;
                     boolean empty = node.get() == null;
-                    
+
                     if (d && empty) {
                         rp.node = null;
                         Throwable ex = error;
@@ -866,15 +866,15 @@ public void drain(ReplayProducer<T> rp) {
                         return;
                     }
                 }
-                
+
                 if (e != 0L) {
                     if (r != Long.MAX_VALUE) {
                         BackpressureUtils.produced(rp.requested, e);
                     }
                 }
-                
+
                 rp.node = node;
-                
+
                 missed = rp.addAndGet(-missed);
                 if (missed == 0) {
                     return;
@@ -885,9 +885,9 @@ public void drain(ReplayProducer<T> rp) {
         static final class Node<T> extends AtomicReference<Node<T>> {
             /** */
             private static final long serialVersionUID = 3713592843205853725L;
-            
+
             final T value;
-            
+
             public Node(T value) {
                 this.value = value;
             }
@@ -932,7 +932,7 @@ public boolean isEmpty() {
         @Override
         public T[] toArray(T[] a) {
             List<T> list = new ArrayList<T>();
-            
+
             Node<T> n = head.get();
             while (n != null) {
                 list.add(n.value);
@@ -945,20 +945,20 @@ public T[] toArray(T[] a) {
 
     static final class ReplaySizeAndTimeBoundBuffer<T> implements ReplayBuffer<T> {
         final int limit;
-        
+
         final long maxAgeMillis;
-        
+
         final Scheduler scheduler;
-        
+
         volatile TimedNode<T> head;
-        
+
         TimedNode<T> tail;
 
         int size;
 
         volatile boolean done;
         Throwable error;
-        
+
         public ReplaySizeAndTimeBoundBuffer(int limit, long maxAgeMillis, Scheduler scheduler) {
             this.limit = limit;
             TimedNode<T> n = new TimedNode<T>(null, 0L);
@@ -971,23 +971,23 @@ public ReplaySizeAndTimeBoundBuffer(int limit, long maxAgeMillis, Scheduler sche
         @Override
         public void next(T value) {
             long now = scheduler.now();
-            
+
             TimedNode<T> n = new TimedNode<T>(value, now);
             tail.set(n);
             tail = n;
-            
+
             now -= maxAgeMillis;
 
             int s = size;
             TimedNode<T> h0 = head;
             TimedNode<T> h = h0;
-            
+
             if (s == limit) {
                 h = h.get();
             } else {
                 s++;
             }
-            
+
             while ((n = h.get()) != null) {
                 if (n.timestamp > now) {
                     break;
@@ -995,7 +995,7 @@ public void next(T value) {
                 h = n;
                 s--;
             }
-            
+
             size = s;
             if (h != h0) {
                 head = h;
@@ -1013,21 +1013,21 @@ public void complete() {
             evictFinal();
             done = true;
         }
-        
+
         void evictFinal() {
             long now = scheduler.now() - maxAgeMillis;
-            
+
             TimedNode<T> h0 = head;
             TimedNode<T> h = h0;
             TimedNode<T> n;
-            
+
             while ((n = h.get()) != null) {
                 if (n.timestamp > now) {
                     break;
                 }
                 h = n;
             }
-            
+
             if (h0 != h) {
                 head = h;
             }
@@ -1045,38 +1045,38 @@ TimedNode<T> latestHead() {
             }
             return h;
         }
-        
+
         @Override
         public void drain(ReplayProducer<T> rp) {
             if (rp.getAndIncrement() != 0) {
                 return;
             }
-            
+
             final Subscriber<? super T> a = rp.actual;
-            
+
             int missed = 1;
-            
+
             for (;;) {
-                
+
                 long r = rp.requested.get();
                 long e = 0L;
-                
+
                 @SuppressWarnings("unchecked")
                 TimedNode<T> node = (TimedNode<T>)rp.node;
                 if (node == null) {
                     node = latestHead();
                 }
-                
+
                 while (e != r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
                         return;
                     }
-                    
+
                     boolean d = done;
                     TimedNode<T> next = node.get();
                     boolean empty = next == null;
-                    
+
                     if (d && empty) {
                         rp.node = null;
                         Throwable ex = error;
@@ -1087,26 +1087,26 @@ public void drain(ReplayProducer<T> rp) {
                         }
                         return;
                     }
-                    
+
                     if (empty) {
                         break;
                     }
-                    
+
                     a.onNext(next.value);
-                    
+
                     e++;
                     node = next;
                 }
-                
+
                 if (e == r) {
                     if (a.isUnsubscribed()) {
                         rp.node = null;
                         return;
                     }
-                    
+
                     boolean d = done;
                     boolean empty = node.get() == null;
-                    
+
                     if (d && empty) {
                         rp.node = null;
                         Throwable ex = error;
@@ -1118,15 +1118,15 @@ public void drain(ReplayProducer<T> rp) {
                         return;
                     }
                 }
-                
+
                 if (e != 0L) {
                     if (r != Long.MAX_VALUE) {
                         BackpressureUtils.produced(rp.requested, e);
                     }
                 }
-                
+
                 rp.node = node;
-                
+
                 missed = rp.addAndGet(-missed);
                 if (missed == 0) {
                     return;
@@ -1137,11 +1137,11 @@ public void drain(ReplayProducer<T> rp) {
         static final class TimedNode<T> extends AtomicReference<TimedNode<T>> {
             /** */
             private static final long serialVersionUID = 3713592843205853725L;
-            
+
             final T value;
-            
+
             final long timestamp;
-            
+
             public TimedNode(T value, long timestamp) {
                 this.value = value;
                 this.timestamp = timestamp;
@@ -1187,7 +1187,7 @@ public boolean isEmpty() {
         @Override
         public T[] toArray(T[] a) {
             List<T> list = new ArrayList<T>();
-            
+
             TimedNode<T> n = latestHead().get();
             while (n != null) {
                 list.add(n.value);
@@ -1204,10 +1204,10 @@ public T[] toArray(T[] a) {
      * <p>
      * The this holds the current work-in-progress indicator used by serializing
      * replays.
-     * 
+     *
      * @param <T> the value type
      */
-    static final class ReplayProducer<T> 
+    static final class ReplayProducer<T>
     extends AtomicInteger
     implements Producer, Subscription {
         /** */
@@ -1215,36 +1215,36 @@ static final class ReplayProducer<T>
 
         /** The wrapped Subscriber instance. */
         final Subscriber<? super T> actual;
-        
+
         /** Holds the current requested amount. */
         final AtomicLong requested;
 
         /** Holds the back-reference to the replay state object. */
         final ReplayState<T> state;
 
-        /** 
+        /**
          * Unbounded buffer.drain() uses this field to remember the absolute index of
          * values replayed to this Subscriber.
          */
         int index;
-        
-        /** 
+
+        /**
          * Unbounded buffer.drain() uses this index within its current node to indicate
          * how many items were replayed from that particular node so far.
          */
         int tailIndex;
-        
-        /** 
+
+        /**
          * Stores the current replay node of the buffer to be used by buffer.drain().
          */
         Object node;
-        
+
         public ReplayProducer(Subscriber<? super T> actual, ReplayState<T> state) {
             this.actual = actual;
             this.requested = new AtomicLong();
             this.state = state;
         }
-        
+
         @Override
         public void unsubscribe() {
             state.remove(this);
diff --git a/src/main/java/rx/subjects/SerializedSubject.java b/src/main/java/rx/subjects/SerializedSubject.java
index 02644d9c9b..9626df896a 100644
--- a/src/main/java/rx/subjects/SerializedSubject.java
+++ b/src/main/java/rx/subjects/SerializedSubject.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -31,7 +31,7 @@
  * <p><pre>{@code
  * mySafeSubject = new SerializedSubject( myUnsafeSubject );
  * }</pre>
- * 
+ *
  * @param <T> the input value type
  * @param <R> the output value type
  */
diff --git a/src/main/java/rx/subjects/Subject.java b/src/main/java/rx/subjects/Subject.java
index f25a6d496b..8f080f2f5e 100644
--- a/src/main/java/rx/subjects/Subject.java
+++ b/src/main/java/rx/subjects/Subject.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -33,12 +33,12 @@ protected Subject(OnSubscribe<R> onSubscribe) {
      * @return true if there is at least one Observer subscribed to this Subject, false otherwise
      */
     public abstract boolean hasObservers();
-    
+
     /**
      * Wraps a {@link Subject} so that it is safe to call its various {@code on} methods from different threads.
      * <p>
-     * When you use an ordinary {@link Subject} as a {@link Subscriber}, you must take care not to call its 
-     * {@link Subscriber#onNext} method (or its other {@code on} methods) from multiple threads, as this could 
+     * When you use an ordinary {@link Subject} as a {@link Subscriber}, you must take care not to call its
+     * {@link Subscriber#onNext} method (or its other {@code on} methods) from multiple threads, as this could
      * lead to non-serialized calls, which violates
      * <a href="http://reactivex.io/documentation/contract.html">the Observable contract</a> and creates an
      * ambiguity in the resulting Subject.
@@ -48,7 +48,7 @@ protected Subject(OnSubscribe<R> onSubscribe) {
      * <p><pre>{@code
      * mySafeSubject = myUnsafeSubject.toSerialized();
      * }</pre>
-     * 
+     *
      * @return SerializedSubject wrapping the current Subject
      */
     public final SerializedSubject<T, R> toSerialized() {
diff --git a/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 53db3f3684..e4ca112c67 100644
--- a/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -72,7 +72,7 @@ public void call() {
                 remove(bo);
             }
         }));
-    }    
+    }
     /** Set the latest NotificationLite value. */
     void setLatest(Object value) {
         latest = value;
@@ -153,7 +153,7 @@ protected static final class State<T> {
         static final SubjectObserver[] NO_OBSERVERS = new SubjectObserver[0];
         static final State TERMINATED = new State(true, NO_OBSERVERS);
         static final State EMPTY = new State(false, NO_OBSERVERS);
-        
+
         public State(boolean terminated, SubjectObserver[] observers) {
             this.terminated = terminated;
             this.observers = observers;
@@ -197,7 +197,7 @@ public State remove(SubjectObserver o) {
             return new State<T>(terminated, b);
         }
     }
-    
+
     /**
      * Observer wrapping the actual Subscriber and providing various
      * emission facilities.
@@ -320,7 +320,7 @@ void accept(Object n, final NotificationLite<T> nl) {
                 nl.accept(actual, n);
             }
         }
-        
+
         /** @return the actual Observer. */
         Observer<? super T> getActual() {
             return actual;
diff --git a/src/main/java/rx/subjects/TestSubject.java b/src/main/java/rx/subjects/TestSubject.java
index 579173a785..6c5cfd2e5a 100644
--- a/src/main/java/rx/subjects/TestSubject.java
+++ b/src/main/java/rx/subjects/TestSubject.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -54,7 +54,7 @@ public static <T> TestSubject<T> create(TestScheduler scheduler) {
             public void call(SubjectObserver<T> o) {
                 o.emitFirst(state.getLatest(), state.nl);
             }
-            
+
         };
         state.onTerminated = state.onAdded;
 
diff --git a/src/main/java/rx/subjects/UnicastSubject.java b/src/main/java/rx/subjects/UnicastSubject.java
index 57459d72d5..92bd62a4f5 100644
--- a/src/main/java/rx/subjects/UnicastSubject.java
+++ b/src/main/java/rx/subjects/UnicastSubject.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -32,7 +32,7 @@
  * amount. In this case, the buffered values are no longer retained. If the Subscriber
  * requests a limited amount, queueing is involved and only those values are retained which
  * weren't requested by the Subscriber at that time.
- * 
+ *
  * @param <T> the input and output value type
  */
 @Experimental
@@ -42,7 +42,7 @@ public final class UnicastSubject<T> extends Subject<T, T> {
 
     /**
      * Constructs an empty UnicastSubject instance with the default capacity hint of 16 elements.
-     * 
+     *
      * @param <T> the input and output value type
      * @return the created UnicastSubject instance
      */
@@ -86,27 +86,27 @@ private UnicastSubject(State<T> state) {
         super(state);
         this.state = state;
     }
-    
+
     @Override
     public void onNext(T t) {
         state.onNext(t);
     }
-    
+
     @Override
     public void onError(Throwable e) {
         state.onError(e);
     }
-    
+
     @Override
     public void onCompleted() {
         state.onCompleted();
     }
-    
+
     @Override
     public boolean hasObservers() {
         return state.subscriber.get() != null;
     }
-    
+
     /**
      * The single-consumption replaying state.
      *
@@ -144,7 +144,7 @@ public State(int capacityHint, Action0 onTerminated) {
             this.nl = NotificationLite.instance();
             this.subscriber = new AtomicReference<Subscriber<? super T>>();
             this.terminateOnce = onTerminated != null ? new AtomicReference<Action0>(onTerminated) : null;
-            
+
             Queue<Object> q;
             if (capacityHint > 1) {
                 q = UnsafeAccess.isUnsafeAvailable()
@@ -157,7 +157,7 @@ public State(int capacityHint, Action0 onTerminated) {
             }
             this.queue = q;
         }
-        
+
         @Override
         public void onNext(T t) {
             if (!done) {
@@ -191,9 +191,9 @@ public void onNext(T t) {
         @Override
         public void onError(Throwable e) {
             if (!done) {
-                
+
                 doTerminate();
-                
+
                 error = e;
                 done = true;
                 if (!caughtUp) {
@@ -229,7 +229,7 @@ public void onCompleted() {
                 subscriber.get().onCompleted();
             }
         }
-        
+
         @Override
         public void request(long n) {
             if (n < 0L) {
@@ -275,14 +275,14 @@ void replay() {
                 if (s != null) {
                     boolean d = done;
                     boolean empty = q.isEmpty();
-                    
+
                     if (checkTerminated(d, empty, s)) {
                         return;
                     }
                     long r = get();
                     unlimited = r == Long.MAX_VALUE;
                     long e = 0L;
-                    
+
                     while (r != 0) {
                         d = done;
                         Object v = q.poll();
@@ -309,7 +309,7 @@ void replay() {
                         addAndGet(-e);
                     }
                 }
-                
+
                 synchronized (this) {
                     if (!missed) {
                         if (unlimited && q.isEmpty()) {
@@ -340,12 +340,12 @@ public void unsubscribe() {
             }
             queue.clear();
         }
-        
+
         @Override
         public boolean isUnsubscribed() {
             return done;
         }
-        
+
         /**
          * Checks if one of the terminal conditions have been met: child unsubscribed,
          * an error happened or the source terminated and the queue is empty
@@ -373,7 +373,7 @@ boolean checkTerminated(boolean done, boolean empty, Subscriber<? super T> s) {
             }
             return false;
         }
-        
+
         /**
          * Call the optional termination action at most once.
          */
diff --git a/src/main/java/rx/subscriptions/BooleanSubscription.java b/src/main/java/rx/subscriptions/BooleanSubscription.java
index 3628e63f91..11a06fda69 100644
--- a/src/main/java/rx/subscriptions/BooleanSubscription.java
+++ b/src/main/java/rx/subscriptions/BooleanSubscription.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java b/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
index ee58c2ea77..8b74d9517a 100644
--- a/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
+++ b/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -25,7 +25,7 @@
 public final class MultipleAssignmentSubscription implements Subscription {
 
     final SequentialSubscription state = new SequentialSubscription();
-    
+
     @Override
     public boolean isUnsubscribed() {
         return state.isUnsubscribed();
diff --git a/src/main/java/rx/subscriptions/RefCountSubscription.java b/src/main/java/rx/subscriptions/RefCountSubscription.java
index dbb38716b7..c615cabbd2 100644
--- a/src/main/java/rx/subscriptions/RefCountSubscription.java
+++ b/src/main/java/rx/subscriptions/RefCountSubscription.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -54,7 +54,7 @@ State unsubscribe() {
 
     /**
      * Creates a {@code RefCountSubscription} by wrapping the given non-null {@code Subscription}.
-     * 
+     *
      * @param s
      *          the {@link Subscription} to wrap
      * @throws IllegalArgumentException
@@ -128,7 +128,7 @@ void unsubscribeAChild() {
     static final class InnerSubscription extends AtomicInteger implements Subscription {
         /** */
         private static final long serialVersionUID = 7005765588239987643L;
-        
+
         final RefCountSubscription parent;
         public InnerSubscription(RefCountSubscription parent) {
             this.parent = parent;
diff --git a/src/main/java/rx/subscriptions/SerialSubscription.java b/src/main/java/rx/subscriptions/SerialSubscription.java
index 5b9590ed25..b86de81152 100644
--- a/src/main/java/rx/subscriptions/SerialSubscription.java
+++ b/src/main/java/rx/subscriptions/SerialSubscription.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -23,9 +23,9 @@
  * the previous underlying subscription to be unsubscribed.
  */
 public final class SerialSubscription implements Subscription {
-    
+
     final SequentialSubscription state = new SequentialSubscription();
-    
+
     @Override
     public boolean isUnsubscribed() {
         return state.isUnsubscribed();
diff --git a/src/main/java/rx/subscriptions/Subscriptions.java b/src/main/java/rx/subscriptions/Subscriptions.java
index db11dfb87b..d9baf671d1 100644
--- a/src/main/java/rx/subscriptions/Subscriptions.java
+++ b/src/main/java/rx/subscriptions/Subscriptions.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -69,7 +69,7 @@ public static Subscription unsubscribed() {
 
     /**
      * Creates and returns a {@link Subscription} that invokes the given {@link Action0} when unsubscribed.
-     * 
+     *
      * @param unsubscribe
      *            Action to invoke on unsubscribe.
      * @return {@link Subscription}
@@ -80,7 +80,7 @@ public static Subscription create(final Action0 unsubscribe) {
 
     /**
      * Converts a {@link Future} into a {@link Subscription} and cancels it when unsubscribed.
-     * 
+     *
      * @param f
      *            the {@link Future} to convert
      * @return a {@link Subscription} that wraps {@code f}
@@ -110,7 +110,7 @@ public boolean isUnsubscribed() {
     /**
      * Converts a set of {@link Subscription}s into a {@link CompositeSubscription} that groups the multiple
      * Subscriptions together and unsubscribes from all of them together.
-     * 
+     *
      * @param subscriptions
      *            the Subscriptions to group together
      * @return a {@link CompositeSubscription} representing the {@code subscriptions} set
diff --git a/src/perf/java/rx/DeferredScalarPerf.java b/src/perf/java/rx/DeferredScalarPerf.java
index cd0f73d465..2419c03efd 100644
--- a/src/perf/java/rx/DeferredScalarPerf.java
+++ b/src/perf/java/rx/DeferredScalarPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -45,16 +45,16 @@ public class DeferredScalarPerf {
     Observable<Integer> reduce;
 
     Observable<Integer> reduceSeed;
-    
+
     Observable<int[]> collect;
 
     @Setup
     public void setup() {
         Integer[] array = new Integer[count];
         Arrays.fill(array, 777);
-        
+
         Observable<Integer> source = Observable.from(array);
-        
+
         reduce = source.reduce(new Func2<Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer a, Integer b) {
@@ -67,9 +67,9 @@ public Integer call(Integer a, Integer b) {
                 return b;
             }
         });
-        
+
         last = source.takeLast(1);
-        
+
         collect = source.collect(new Func0<int[]>() {
             @Override
             public int[] call() {
@@ -77,12 +77,12 @@ public int[] call() {
             }
         }, new Action2<int[], Integer>() {
             @Override
-            public void call(int[] a, Integer b) { 
-                a[0] = b.intValue(); 
+            public void call(int[] a, Integer b) {
+                a[0] = b.intValue();
             }
         } );
     }
-    
+
     @Benchmark
     public void reduce(Blackhole bh) {
         reduce.subscribe(new LatchedObserver<Integer>(bh));
diff --git a/src/perf/java/rx/ObservablePerfBaseline.java b/src/perf/java/rx/ObservablePerfBaseline.java
index 061caf6264..bbf049ada9 100644
--- a/src/perf/java/rx/ObservablePerfBaseline.java
+++ b/src/perf/java/rx/ObservablePerfBaseline.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -54,7 +54,7 @@ public void observableConsumption(Input input) throws InterruptedException {
     public void observableViaRange(Input input) throws InterruptedException {
         input.observable.subscribe(input.observer);
     }
-    
+
     @Benchmark
     public void observableConsumptionUnsafe(Input input) throws InterruptedException {
         input.firehose.unsafeSubscribe(input.newSubscriber());
diff --git a/src/perf/java/rx/OneItemPerf.java b/src/perf/java/rx/OneItemPerf.java
index c864164db8..43c6539992 100644
--- a/src/perf/java/rx/OneItemPerf.java
+++ b/src/perf/java/rx/OneItemPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -37,7 +37,7 @@
 @OutputTimeUnit(TimeUnit.SECONDS)
 @State(Scope.Thread)
 public class OneItemPerf {
-    
+
     Observable<Integer> scalar;
     Observable<Integer> scalarHidden;
     Observable<Integer> one;
@@ -57,7 +57,7 @@ public class OneItemPerf {
     Observable<Integer> scalarSwitch;
     Observable<Integer> scalarHiddenSwitch;
     Observable<Integer> oneSwitch;
-    
+
     <T> Single<T> hide(final Single<T> single) {
         return Single.create(new Single.OnSubscribe<T>() {
             @Override
@@ -66,7 +66,7 @@ public void call(SingleSubscriber<? super T> t) {
             }
         });
     }
-    
+
     @Setup
     public void setup() {
         scalar = Observable.just(1);
@@ -79,9 +79,9 @@ public void call(Subscriber<? super Integer> t) {
         single = Single.just(1);
         singleHidden = hide(single);
         scalarHidden = scalar.asObservable();
-        
+
         // ----------------------------------------------------------------------------
-        
+
         scalarConcat = scalar.concatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -94,7 +94,7 @@ public Observable<Integer> call(Integer v) {
                 return scalar;
             }
         });
-        
+
         oneConcat  = one.concatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -116,7 +116,7 @@ public Observable<Integer> call(Integer v) {
                 return scalar;
             }
         });
-        
+
         oneMerge  = one.flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -135,9 +135,9 @@ public Single<Integer> call(Integer v) {
                 return single;
             }
         });
-        
+
         // ----------------------------------------------------------------------------
-        
+
         scalarSwitch = scalar.switchMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -150,7 +150,7 @@ public Observable<Integer> call(Integer v) {
                 return scalar;
             }
         });
-        
+
         oneSwitch  = one.switchMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -158,7 +158,7 @@ public Observable<Integer> call(Integer v) {
             }
         });
     }
-    
+
     @Benchmark
     public void scalar(Blackhole bh) {
         scalar.subscribe(new LatchedObserver<Integer>(bh));
diff --git a/src/perf/java/rx/ScalarJustPerf.java b/src/perf/java/rx/ScalarJustPerf.java
index 24543852ff..548d1764fd 100644
--- a/src/perf/java/rx/ScalarJustPerf.java
+++ b/src/perf/java/rx/ScalarJustPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -42,26 +42,26 @@ static final class PlainSubscriber extends Subscriber<Integer> {
         public PlainSubscriber(Blackhole bh) {
             this.bh = bh;
         }
-        
+
         @Override
         public void onNext(Integer t) {
             bh.consume(t);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             bh.consume(e);
         }
-        
+
         @Override
         public void onCompleted() {
             bh.consume(false);
         }
     }
-    
+
     /** This is a simple just. */
     Observable<Integer> simple;
-    /** 
+    /**
      * This is a simple just observed on the computation scheduler.
      * The current computation scheduler supports direct scheduling and should have
      * lower overhead than a regular createWorker-use-unsubscribe.
@@ -69,8 +69,8 @@ public void onCompleted() {
     Observable<Integer> observeOn;
     /** This is a simple just observed on the IO thread. */
     Observable<Integer> observeOnIO;
-    
-    /** 
+
+    /**
      * This is a simple just subscribed to on the computation scheduler.
      * In theory, for non-backpressured just(), this should be the
      * same as observeOn.
@@ -81,29 +81,29 @@ public void onCompleted() {
 
     /** This is a just mapped to itself which should skip the operator flatMap completely. */
     Observable<Integer> justFlatMapJust;
-    /** 
+    /**
      * This is a just mapped to a range of 2 elements; it tests the case where the inner
      * Observable isn't a just().
      */
     Observable<Integer> justFlatMapRange;
-    
+
     @Setup
     public void setup() {
         simple = Observable.just(1);
-        
+
         observeOn = simple.observeOn(Schedulers.computation());
         observeOnIO = simple.observeOn(Schedulers.io());
-        
+
         subscribeOn = simple.subscribeOn(Schedulers.computation());
         subscribeOnIO = simple.subscribeOn(Schedulers.io());
-        
+
         justFlatMapJust = simple.flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
                 return Observable.just(v);
             }
         });
-        
+
         justFlatMapRange = simple.flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -123,12 +123,12 @@ public Observable<Integer> call(Integer v) {
      */
     void runAsync(Blackhole bh, Observable<Integer> source) {
         LatchedObserver<Integer> lo = new LatchedObserver<Integer>(bh);
-        
+
         source.subscribe(lo);
-        
+
         while (lo.latch.getCount() != 0L);
     }
-    
+
     @Benchmark
     public void simple(Blackhole bh) {
         PlainSubscriber s = new PlainSubscriber(bh);
@@ -148,12 +148,12 @@ public Object simpleEscapeAll(Blackhole bh) {
         bh.consume(s);
         return simple.subscribe(s);
     }
-    
+
     @Benchmark
     public void observeOn(Blackhole bh) {
         runAsync(bh, observeOn);
     }
-    
+
     @Benchmark
     public void observeOnIO(Blackhole bh) {
         runAsync(bh, observeOnIO);
@@ -163,18 +163,18 @@ public void observeOnIO(Blackhole bh) {
     public void subscribeOn(Blackhole bh) {
         runAsync(bh, subscribeOn);
     }
-    
+
     @Benchmark
     public void subscribeOnIO(Blackhole bh) {
         runAsync(bh, subscribeOnIO);
     }
-    
+
     @Benchmark
     public void justFlatMapJust(Blackhole bh) {
         PlainSubscriber s = new PlainSubscriber(bh);
         justFlatMapJust.subscribe(s);
     }
-    
+
     @Benchmark
     public void justFlatMapJustEscape(Blackhole bh) {
         PlainSubscriber s = new PlainSubscriber(bh);
@@ -187,7 +187,7 @@ public void justFlatMapRange(Blackhole bh) {
         PlainSubscriber s = new PlainSubscriber(bh);
         justFlatMapRange.subscribe(s);
     }
-    
+
     @Benchmark
     public void justFlatMapRangeEscape(Blackhole bh) {
         PlainSubscriber s = new PlainSubscriber(bh);
diff --git a/src/perf/java/rx/SinglePerfBaseline.java b/src/perf/java/rx/SinglePerfBaseline.java
index e1a646cef0..954cc354be 100644
--- a/src/perf/java/rx/SinglePerfBaseline.java
+++ b/src/perf/java/rx/SinglePerfBaseline.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -38,12 +38,12 @@ public class SinglePerfBaseline {
     public void singleConsumption(Input input) throws InterruptedException {
         input.single.subscribe(input.newSubscriber());
     }
-    
+
     @Benchmark
     public void singleConsumptionUnsafe(Input input) throws InterruptedException {
         input.single.unsafeSubscribe(input.newSubscriber());
     }
-    
+
     @Benchmark
     public void newSingleAndSubscriberEachTime(Input input) throws InterruptedException {
         input.newSingle().subscribe(input.newSubscriber());
@@ -63,7 +63,7 @@ public void setup(final Blackhole bh) {
         public LatchedObserver<Integer> newLatchedObserver() {
             return new LatchedObserver<Integer>(bh);
         }
-        
+
         public Single<Integer> newSingle() {
             return Single.create(new OnSubscribe<Integer>() {
 
@@ -71,7 +71,7 @@ public Single<Integer> newSingle() {
                 public void call(SingleSubscriber<? super Integer> t) {
                     t.onSuccess(1);
                 }
-                
+
             });
         }
 
diff --git a/src/perf/java/rx/SingleSourcePerf.java b/src/perf/java/rx/SingleSourcePerf.java
index fff9006ea6..c735e4e2b0 100644
--- a/src/perf/java/rx/SingleSourcePerf.java
+++ b/src/perf/java/rx/SingleSourcePerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -35,7 +35,7 @@
 @OutputTimeUnit(TimeUnit.SECONDS)
 @State(Scope.Thread)
 public class SingleSourcePerf {
-    
+
     Single<Integer> source;
 
     Single<Integer> flatmapped;
@@ -59,74 +59,74 @@ public class SingleSourcePerf {
 //    Single<Integer> sourceSubscribeOnFJ;
 
     ScheduledExecutorService scheduledExecutor;
-    
+
     ExecutorService executor;
 
     @Setup
     public void setup() {
         source = Single.just(1);
-        
+
         flatmapped = source.flatMap(new Func1<Integer, Single<Integer>>() {
             @Override
             public Single<Integer> call(Integer t) {
                 return Single.just(t);
             }
         });
-        
+
         flatmapped = source.flatMap(new Func1<Integer, Single<Integer>>() {
             @Override
             public Single<Integer> call(Integer t) {
                 return source;
             }
         });
-        
+
         sourceObserveOn = source.observeOn(Schedulers.computation());
 
         sourceSubscribeOn = source.subscribeOn(Schedulers.computation());
-        
+
         // ----------
-        
+
         scheduledExecutor = Executors.newScheduledThreadPool(1);
-        
+
         Scheduler s = Schedulers.from(scheduledExecutor);
-        
+
         sourceObserveOnScheduledExecutor = source.observeOn(s);
 
         sourceSubscribeOnScheduledExecutor = source.subscribeOn(s);
-        
+
         // ----------
-        
+
         executor = Executors.newSingleThreadExecutor();
-        
+
         Scheduler se = Schedulers.from(executor);
-        
+
         sourceObserveOnExecutor = source.observeOn(se);
 
         sourceSubscribeOnExecutor = source.subscribeOn(se);
-        
+
         // --------
-        
+
 //        Scheduler fj = Schedulers.from(ForkJoinPool.commonPool());
-        
+
 //        sourceObserveOnFJ = source.observeOn(fj);
 
 //        sourceSubscribeOnFJ = source.subscribeOn(fj);
     }
-    
+
     @TearDown
     public void teardown() {
         scheduledExecutor.shutdownNow();
-        
+
         executor.shutdownNow();
     }
-    
+
     static final class PlainSingleSubscriber extends SingleSubscriber<Object> {
         final Blackhole bh;
-        
+
         public PlainSingleSubscriber(Blackhole bh) {
             this.bh = bh;
         }
-        
+
         @Override
         public void onSuccess(Object value) {
             bh.consume(value);
@@ -140,14 +140,14 @@ public void onError(Throwable error) {
 
     static final class LatchedSingleSubscriber extends SingleSubscriber<Object> {
         final Blackhole bh;
-        
+
         final CountDownLatch cdl;
-        
+
         public LatchedSingleSubscriber(Blackhole bh) {
             this.bh = bh;
             this.cdl = new CountDownLatch(1);
         }
-        
+
         @Override
         public void onSuccess(Object value) {
             bh.consume(value);
@@ -159,7 +159,7 @@ public void onError(Throwable error) {
             bh.consume(error);
             cdl.countDown();
         }
-        
+
         public void await() {
             try {
                 cdl.await();
@@ -167,7 +167,7 @@ public void await() {
                 throw new RuntimeException(ex);
             }
         }
-        
+
         public void awaitSpin() {
             while (cdl.getCount() != 0L) ;
         }
@@ -182,7 +182,7 @@ public void direct(Blackhole bh) {
     public void flatmap(Blackhole bh) {
         flatmapped.subscribe(new PlainSingleSubscriber(bh));
     }
-    
+
     @Benchmark
     public void flatmapConst(Blackhole bh) {
         flatmapped.subscribe(new PlainSingleSubscriber(bh));
@@ -191,72 +191,72 @@ public void flatmapConst(Blackhole bh) {
     @Benchmark
     public void observeOn(Blackhole bh) {
         LatchedSingleSubscriber o = new LatchedSingleSubscriber(bh);
-        
+
         sourceObserveOn.subscribe(o);
-        
+
         o.awaitSpin();
     }
 
     @Benchmark
     public void observeOnExec(Blackhole bh) {
         LatchedSingleSubscriber o = new LatchedSingleSubscriber(bh);
-        
+
         sourceObserveOnExecutor.subscribe(o);
-        
+
         o.awaitSpin();
     }
 
     @Benchmark
     public void subscribeOn(Blackhole bh) {
         LatchedSingleSubscriber o = new LatchedSingleSubscriber(bh);
-        
+
         sourceSubscribeOn.subscribe(o);
-        
+
         o.awaitSpin();
     }
 
     @Benchmark
     public void subscribeOnExec(Blackhole bh) {
         LatchedSingleSubscriber o = new LatchedSingleSubscriber(bh);
-        
+
         sourceSubscribeOnExecutor.subscribe(o);
-        
+
         o.awaitSpin();
     }
 
     @Benchmark
     public void subscribeOnSchExec(Blackhole bh) {
         LatchedSingleSubscriber o = new LatchedSingleSubscriber(bh);
-        
+
         sourceSubscribeOnScheduledExecutor.subscribe(o);
-        
+
         o.awaitSpin();
     }
 
 //    @Benchmark
 //    public void subscribeOnFJ(Blackhole bh) {
 //        LatchedSingleSubscriber o = new LatchedSingleSubscriber(bh);
-//        
+//
 //        sourceSubscribeOnFJ.subscribe(o);
-//        
+//
 //        o.awaitSpin();
 //    }
 
     @Benchmark
     public void observeOnSchExec(Blackhole bh) {
         LatchedSingleSubscriber o = new LatchedSingleSubscriber(bh);
-        
+
         sourceObserveOnScheduledExecutor.subscribe(o);
-        
+
         o.awaitSpin();
     }
 
 //    @Benchmark
 //    public void observeOnFJ(Blackhole bh) {
 //        LatchedSingleSubscriber o = new LatchedSingleSubscriber(bh);
-//        
+//
 //        sourceObserveOnFJ.subscribe(o);
-//        
+//
 //        o.awaitSpin();
 //    }
 
diff --git a/src/perf/java/rx/SubscribingPerf.java b/src/perf/java/rx/SubscribingPerf.java
index f172f00852..4f89cab1eb 100644
--- a/src/perf/java/rx/SubscribingPerf.java
+++ b/src/perf/java/rx/SubscribingPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -34,10 +34,10 @@
 @OutputTimeUnit(TimeUnit.SECONDS)
 @State(Scope.Thread)
 public class SubscribingPerf {
-    
+
     Observable<Integer> just = Observable.just(1);
     Observable<Integer> range = Observable.range(1, 2);
-    
+
     @Benchmark
     public void justDirect(Blackhole bh) {
         DirectSubscriber<Integer> subscriber = new DirectSubscriber<Integer>(Long.MAX_VALUE, bh);
@@ -126,16 +126,16 @@ public void rangeUsualUnsafe(Blackhole bh) {
     public static class Chain {
         @Param({"10", "1000", "1000000"})
         public int times;
-        
+
         @Param({"1", "2", "3", "4", "5"})
         public int maps;
-        
+
         Observable<Integer> source;
-        
+
         @Setup
         public void setup() {
             Observable<Integer> o = Observable.range(1, times);
-            
+
             for (int i = 0; i < maps; i++) {
                 o = o.map(new Func1<Integer, Integer>() {
                     @Override
@@ -144,10 +144,10 @@ public Integer call(Integer v) {
                     }
                 });
             }
-            
+
             source = o;
         }
-        
+
         @Benchmark
         public void mapped(Chain c, Blackhole bh) {
             DirectSubscriber<Integer> subscriber = new DirectSubscriber<Integer>(Long.MAX_VALUE, bh);
@@ -155,7 +155,7 @@ public void mapped(Chain c, Blackhole bh) {
             c.source.subscribe(subscriber);
         }
     }
-    
+
     static final class DirectSubscriber<T> extends Subscriber<T> {
         final long r;
         final Blackhole bh;
@@ -167,16 +167,16 @@ public DirectSubscriber(long r, Blackhole bh) {
         public void onNext(T t) {
             bh.consume(t);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             e.printStackTrace();
         }
-        
+
         @Override
         public void onCompleted() {
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             p.request(r);
@@ -190,25 +190,25 @@ public StartedSubscriber(long r, Blackhole bh) {
             this.r = r;
             this.bh = bh;
         }
-        
+
         @Override
         public void onStart() {
             request(r);
         }
-        
+
         @Override
         public void onNext(T t) {
             bh.consume(t);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             e.printStackTrace();
         }
-        
+
         @Override
         public void onCompleted() {
-            
+
         }
     }
 
@@ -222,20 +222,20 @@ public UsualSubscriber(long r, Blackhole bh) {
             this.bh = bh;
             request(r);
         }
-        
+
         @Override
         public void onNext(T t) {
             bh.consume(t);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             e.printStackTrace();
         }
-        
+
         @Override
         public void onCompleted() {
-            
+
         }
     }
 }
diff --git a/src/perf/java/rx/internal/AtomicPerf.java b/src/perf/java/rx/internal/AtomicPerf.java
index 3d845056b4..605bf31258 100644
--- a/src/perf/java/rx/internal/AtomicPerf.java
+++ b/src/perf/java/rx/internal/AtomicPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -74,9 +74,9 @@ public static class AtomicIntState {
     public static class AtomicLongState {
         public final AtomicLong value = new AtomicLong();
     }
-    
+
     // -----------------------------------------------------------------------------------
-    
+
     @Benchmark
     public void volatileIntRead(VolatileIntState state, Times repeat, Blackhole bh) {
         for (int i = 0; i < repeat.times; i++) {
@@ -126,7 +126,7 @@ public void atomicLongGetAndIncrement(AtomicLongState state, Times repeat, Black
             bh.consume(state.value.getAndIncrement());
         }
     }
-    
+
     @Benchmark
     public void atomicIntLazySet(AtomicIntState state, Times repeat, Blackhole bh) {
         for (int i = 0; i < repeat.times; i++) {
@@ -225,7 +225,7 @@ public void atomicLongFieldGetAndIncrement(VolatileLongFieldState state, Times r
             bh.consume(VolatileLongFieldState.UPDATER.getAndIncrement(state));
         }
     }
-    
+
     @Benchmark
     public void atomicIntFieldLazySet(VolatileIntFieldState state, Times repeat, Blackhole bh) {
         for (int i = 0; i < repeat.times; i++) {
diff --git a/src/perf/java/rx/internal/IndexedRingBufferPerf.java b/src/perf/java/rx/internal/IndexedRingBufferPerf.java
index e523e337a6..890be86430 100644
--- a/src/perf/java/rx/internal/IndexedRingBufferPerf.java
+++ b/src/perf/java/rx/internal/IndexedRingBufferPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/perf/java/rx/jmh/InputWithIncrementingInteger.java b/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
index 6760202024..ad0c350c2d 100644
--- a/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
+++ b/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
@@ -60,21 +60,21 @@ public void call(Subscriber<? super Integer> s) {
             public Iterator<Integer> iterator() {
                 return new Iterator<Integer>() {
                     int i = 0;
-                    
+
                     @Override
                     public boolean hasNext() {
                         return i < size;
                     }
-                    
+
                     @Override
                     public Integer next() {
                         Blackhole.consumeCPU(10);
                         return i++;
                     }
-                    
+
                     @Override
                     public void remove() {
-                        
+
                     }
                 };
             }
diff --git a/src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java b/src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java
index dba6f563df..01d7600d6f 100644
--- a/src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java
+++ b/src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java
@@ -29,26 +29,26 @@
  */
 public final class PerfAsyncSingleSubscriber extends SingleSubscriber<Object> {
     final Blackhole bh;
-    
+
     final CountDownLatch cdl;
-    
+
     public PerfAsyncSingleSubscriber(Blackhole bh) {
         this.bh = bh;
         this.cdl = new CountDownLatch(1);
     }
-    
+
     @Override
     public void onSuccess(Object value) {
         bh.consume(value);
         cdl.countDown();
     }
-    
+
     @Override
     public void onError(Throwable error) {
         bh.consume(error);
         cdl.countDown();
     }
-    
+
     /**
      * Sleeps until the subscriber receives an event.
      */
@@ -59,7 +59,7 @@ public void sleepAwait() {
             throw new RuntimeException(ex);
         }
     }
-    
+
     /**
      * Spins until the subscriber receives an events.
      */
diff --git a/src/perf/java/rx/jmh/PerfSingleSubscriber.java b/src/perf/java/rx/jmh/PerfSingleSubscriber.java
index d46f6a99bf..57458d1000 100644
--- a/src/perf/java/rx/jmh/PerfSingleSubscriber.java
+++ b/src/perf/java/rx/jmh/PerfSingleSubscriber.java
@@ -25,16 +25,16 @@
  */
 public final class PerfSingleSubscriber extends SingleSubscriber<Object> {
     final Blackhole bh;
-    
+
     public PerfSingleSubscriber(Blackhole bh) {
         this.bh = bh;
     }
-    
+
     @Override
     public void onSuccess(Object value) {
         bh.consume(value);
     }
-    
+
     @Override
     public void onError(Throwable error) {
         bh.consume(error);
diff --git a/src/perf/java/rx/observables/MultiInput.java b/src/perf/java/rx/observables/MultiInput.java
index e607249d07..2b41337532 100644
--- a/src/perf/java/rx/observables/MultiInput.java
+++ b/src/perf/java/rx/observables/MultiInput.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/perf/java/rx/observables/SingleInput.java b/src/perf/java/rx/observables/SingleInput.java
index 7949efcfa5..5bda399ceb 100644
--- a/src/perf/java/rx/observables/SingleInput.java
+++ b/src/perf/java/rx/observables/SingleInput.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/perf/java/rx/observables/SyncOnSubscribePerf.java b/src/perf/java/rx/observables/SyncOnSubscribePerf.java
index f99a01a421..54377e433b 100644
--- a/src/perf/java/rx/observables/SyncOnSubscribePerf.java
+++ b/src/perf/java/rx/observables/SyncOnSubscribePerf.java
@@ -47,7 +47,7 @@ private static Blackhole _jmh_tryInit_() {
             return new Blackhole();
         }
     }
-    
+
     private static OnSubscribe<Integer> createSyncOnSubscribe(final Iterator<Integer> iterator) {
         return new SyncOnSubscribe<Void, Integer>(){
 
@@ -67,7 +67,7 @@ protected Void next(Void state, Observer<? super Integer> observer) {
                 }
             };
     }
-    
+
 //    @Benchmark
 //  @Group("single")
     public void benchSyncOnSubscribe(final SingleInput input) {
@@ -79,13 +79,13 @@ public void benchSyncOnSubscribe(final SingleInput input) {
     public void benchFromIterable(final SingleInput input) {
         new OnSubscribeFromIterable<Integer>(input.iterable).call(input.newSubscriber());
     }
-    
+
     @Benchmark
 //    @Group("multi")
     public void benchSyncOnSubscribe2(final MultiInput input) {
         createSyncOnSubscribe(input.iterable.iterator()).call(input.newSubscriber());
     }
-    
+
     @Benchmark
 //    @Group("multi")
     public void benchFromIterable2(final MultiInput input) {
diff --git a/src/perf/java/rx/operators/ConcatMapInterablePerf.java b/src/perf/java/rx/operators/ConcatMapInterablePerf.java
index 40ea778acb..2fd278d25c 100644
--- a/src/perf/java/rx/operators/ConcatMapInterablePerf.java
+++ b/src/perf/java/rx/operators/ConcatMapInterablePerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -47,21 +47,21 @@ public class ConcatMapInterablePerf {
 
     @Param({"1", "10", "100", "1000", "10000", "100000", "1000000"})
     public int count;
-    
+
     Observable<Integer> justPlain;
-    
+
     Observable<Integer> justIterable;
 
     Observable<Integer> rangePlain;
-    
+
     Observable<Integer> rangeIterable;
 
     Observable<Integer> xrangePlain;
-    
+
     Observable<Integer> xrangeIterable;
 
     Observable<Integer> chainPlain;
-    
+
     Observable<Integer> chainIterable;
 
     @Setup
@@ -70,13 +70,13 @@ public void setup() {
         for (int i = 0; i < count; i++) {
             values[i] = i;
         }
-        
+
         int c = 1000000 / count;
         Integer[] xvalues = new Integer[c];
         for (int i = 0; i < c; i++) {
             xvalues[i] = i;
         }
-        
+
         Observable<Integer> source = Observable.from(values);
 
         justPlain = source.concatMap(new Func1<Integer, Observable<Integer>>() {
@@ -94,7 +94,7 @@ public Iterable<Integer> call(Integer v) {
 
         final Observable<Integer> range = Observable.range(1, 2);
         final List<Integer> xrange = Arrays.asList(1, 2);
-        
+
         rangePlain = source.concatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -107,10 +107,10 @@ public Iterable<Integer> call(Integer v) {
                 return xrange;
             }
         });
-        
+
         final Observable<Integer> xsource = Observable.from(xvalues);
         final List<Integer> xvaluesList = Arrays.asList(xvalues);
-        
+
         xrangePlain = source.concatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -137,7 +137,7 @@ public Iterable<Integer> call(Integer v) {
             }
         });
     }
-    
+
     @Benchmark
     public void justPlain(Blackhole bh) {
         justPlain.subscribe(new LatchedObserver<Integer>(bh));
diff --git a/src/perf/java/rx/operators/ConcatPerf.java b/src/perf/java/rx/operators/ConcatPerf.java
index c9c5e8e18f..cab3ce7881 100644
--- a/src/perf/java/rx/operators/ConcatPerf.java
+++ b/src/perf/java/rx/operators/ConcatPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -44,25 +44,25 @@
 public class ConcatPerf {
 
     Observable<Integer> source;
-    
+
     Observable<Integer> baseline;
-    
+
     @Param({"1", "1000", "1000000"})
     int count;
-    
+
     @Setup
     public void setup() {
         Integer[] array = new Integer[count];
-        
+
         for (int i = 0; i < count; i++) {
             array[i] = 777;
         }
-        
+
         baseline = Observable.from(array);
-        
+
         source = Observable.concat(baseline, Observable.<Integer>empty());
     }
-    
+
     @Benchmark
     public void normal(Blackhole bh) {
         source.subscribe(new LatchedObserver<Integer>(bh));
diff --git a/src/perf/java/rx/operators/FlatMapAsFilterPerf.java b/src/perf/java/rx/operators/FlatMapAsFilterPerf.java
index e8ca109fdf..df90cd48be 100644
--- a/src/perf/java/rx/operators/FlatMapAsFilterPerf.java
+++ b/src/perf/java/rx/operators/FlatMapAsFilterPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -39,16 +39,16 @@ public class FlatMapAsFilterPerf {
 
     @Param({"1", "1000", "1000000"})
     public int count;
-    
+
     @Param({"0", "1", "3", "7"})
     public int mask;
-    
+
     public Observable<Integer> justEmptyFlatMap;
-    
+
     public Observable<Integer> rangeEmptyFlatMap;
 
     public Observable<Integer> justEmptyConcatMap;
-    
+
     public Observable<Integer> rangeEmptyConcatMap;
 
     @Setup
@@ -61,20 +61,20 @@ public void setup() {
             values[i] = i;
         }
         final Observable<Integer> just = Observable.just(1);
-        
+
         final Observable<Integer> range = Observable.range(1, 2);
-        
+
         final Observable<Integer> empty = Observable.empty();
-        
+
         final int m = mask;
-        
+
         justEmptyFlatMap = Observable.from(values).flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
                 return (v & m) == 0 ? empty : just;
             }
         });
-        
+
         rangeEmptyFlatMap = Observable.from(values).flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -88,7 +88,7 @@ public Observable<Integer> call(Integer v) {
                 return (v & m) == 0 ? empty : just;
             }
         });
-        
+
         rangeEmptyConcatMap = Observable.from(values).concatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -101,7 +101,7 @@ public Observable<Integer> call(Integer v) {
     public void justEmptyFlatMap(Blackhole bh) {
         justEmptyFlatMap.subscribe(new LatchedObserver<Integer>(bh));
     }
-    
+
     @Benchmark
     public void rangeEmptyFlatMap(Blackhole bh) {
         rangeEmptyFlatMap.subscribe(new LatchedObserver<Integer>(bh));
@@ -111,7 +111,7 @@ public void rangeEmptyFlatMap(Blackhole bh) {
     public void justEmptyConcatMap(Blackhole bh) {
         justEmptyConcatMap.subscribe(new LatchedObserver<Integer>(bh));
     }
-    
+
     @Benchmark
     public void rangeEmptyConcatMap(Blackhole bh) {
         rangeEmptyConcatMap.subscribe(new LatchedObserver<Integer>(bh));
diff --git a/src/perf/java/rx/operators/FlatMapPerf.java b/src/perf/java/rx/operators/FlatMapPerf.java
index f8dafd467d..970a213935 100644
--- a/src/perf/java/rx/operators/FlatMapPerf.java
+++ b/src/perf/java/rx/operators/FlatMapPerf.java
@@ -42,7 +42,7 @@ public class FlatMapPerf {
 
     Observable<Integer> rxSource;
     Observable<Integer> rxSource2;
-    
+
     @Setup
     public void setup() {
         Observable<Integer> rxRange = Observable.range(0, times);
@@ -59,7 +59,7 @@ public Observable<Integer> call(Integer v) {
             }
         });
     }
-    
+
     @Benchmark
     public Object rxFlatMap() {
         return rxSource.subscribe();
diff --git a/src/perf/java/rx/operators/FlatMapRangePerf.java b/src/perf/java/rx/operators/FlatMapRangePerf.java
index e8d58795b7..93e04d0345 100644
--- a/src/perf/java/rx/operators/FlatMapRangePerf.java
+++ b/src/perf/java/rx/operators/FlatMapRangePerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -38,14 +38,14 @@
 public class FlatMapRangePerf {
     @Param({ "1", "10", "1000", "1000000" })
     public int times;
-    
+
     Observable<Integer> rangeFlatMapJust;
     Observable<Integer> rangeFlatMapRange;
-    
+
     @Setup
     public void setup() {
         Observable<Integer> range = Observable.range(1, times);
-        
+
         rangeFlatMapJust = range.flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -59,7 +59,7 @@ public Observable<Integer> call(Integer v) {
             }
         });
     }
-    
+
     @Benchmark
     public void rangeFlatMapJust(Blackhole bh) {
         rangeFlatMapJust.subscribe(new LatchedObserver<Object>(bh));
diff --git a/src/perf/java/rx/operators/FromComparison.java b/src/perf/java/rx/operators/FromComparison.java
index 7a7a12545d..3ba2d3c751 100644
--- a/src/perf/java/rx/operators/FromComparison.java
+++ b/src/perf/java/rx/operators/FromComparison.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -38,21 +38,21 @@
 public class FromComparison {
     @Param({ "1", "10", "100", "1000", "1000000" })
     public int times;
-    
+
     Observable<Integer> iterableSource;
-    
+
     Observable<Integer> arraySource;
-    
+
     @Setup
     public void setup() {
         Integer[] array = new Integer[times];
-        
+
         Arrays.fill(array, 1);
-        
+
         iterableSource = Observable.create(new OnSubscribeFromIterable<Integer>(Arrays.asList(array)));
         arraySource = Observable.create(new OnSubscribeFromArray<Integer>(array));
     }
-    
+
     @Benchmark
     public void fastpathIterable(Blackhole bh) {
         iterableSource.subscribe(new RequestingSubscriber<Object>(bh, Long.MAX_VALUE));
@@ -83,18 +83,18 @@ public void slowpathArray2(Blackhole bh) {
         arraySource.subscribe(new RequestingSubscriber<Object>(bh, 128));
     }
 
-    
+
     static final class RequestingSubscriber<T> extends Subscriber<T> {
         final Blackhole bh;
         final long limit;
         long received;
         Producer p;
-        
+
         public RequestingSubscriber(Blackhole bh, long limit) {
             this.bh = bh;
             this.limit = limit;
         }
-        
+
         @Override
         public void onNext(T t) {
             bh.consume(t);
@@ -103,17 +103,17 @@ public void onNext(T t) {
                 p.request(limit);
             }
         }
-        
+
         @Override
         public void onError(Throwable e) {
             e.printStackTrace();
         }
-        
+
         @Override
         public void onCompleted() {
-            
+
         }
-        
+
         @Override
         public void setProducer(Producer p) {
             this.p = p;
diff --git a/src/perf/java/rx/operators/FromIterablePerf.java b/src/perf/java/rx/operators/FromIterablePerf.java
index 1368fcbf30..0e412999d8 100644
--- a/src/perf/java/rx/operators/FromIterablePerf.java
+++ b/src/perf/java/rx/operators/FromIterablePerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -41,7 +41,7 @@ public class FromIterablePerf {
     OnSubscribeFromIterable<Integer> direct;
     @Param({"1", "1000", "1000000"})
     public int size;
-    
+
     @Setup
     public void setup() {
         Integer[] array = new Integer[size];
@@ -51,7 +51,7 @@ public void setup() {
         from = Observable.from(Arrays.asList(array));
         direct = new OnSubscribeFromIterable<Integer>(Arrays.asList(array));
     }
-    
+
     @Benchmark
     public void from(Blackhole bh) {
         from.subscribe(new LatchedObserver<Integer>(bh));
@@ -60,12 +60,12 @@ public void from(Blackhole bh) {
     public void fromUnsafe(final Blackhole bh) {
         from.unsafeSubscribe(createSubscriber(bh));
     }
-    
+
     @Benchmark
     public void direct(final Blackhole bh) {
         direct.call(createSubscriber(bh));
     }
-    
+
     Subscriber<Integer> createSubscriber(final Blackhole bh) {
         return new Subscriber<Integer>() {
             @Override
@@ -78,7 +78,7 @@ public void onError(Throwable e) {
             }
             @Override
             public void onCompleted() {
-                
+
             }
         };
     }
diff --git a/src/perf/java/rx/operators/OperatorObserveOnPerf.java b/src/perf/java/rx/operators/OperatorObserveOnPerf.java
index a105f09548..5a7f7cfb94 100644
--- a/src/perf/java/rx/operators/OperatorObserveOnPerf.java
+++ b/src/perf/java/rx/operators/OperatorObserveOnPerf.java
@@ -45,7 +45,7 @@ public int getSize() {
         }
 
     }
-    
+
     @Benchmark
     public void observeOnComputation(Input input) throws InterruptedException {
         LatchedObserver<Integer> o = input.newLatchedObserver();
@@ -66,7 +66,7 @@ public void observeOnImmediate(Input input) throws InterruptedException {
         input.observable.observeOn(Schedulers.immediate()).subscribe(o);
         o.latch.await();
     }
-    
+
     @Benchmark
     public void observeOnComputationSubscribedOnComputation(Input input) throws InterruptedException {
         LatchedObserver<Integer> o = input.newLatchedObserver();
diff --git a/src/perf/java/rx/operators/OperatorPublishPerf.java b/src/perf/java/rx/operators/OperatorPublishPerf.java
index 1658917c29..e2fae22b0c 100644
--- a/src/perf/java/rx/operators/OperatorPublishPerf.java
+++ b/src/perf/java/rx/operators/OperatorPublishPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -72,8 +72,8 @@ public void onCompleted() {
             cdl.countDown();
         }
     }
-    
-    
+
+
     /** How long the range should be. */
     @Param({"1", "1000", "1000000"})
     private int size;
@@ -86,7 +86,7 @@ public void onCompleted() {
     /** How often the child subscribers should re-request. */
     @Param({"1", "2", "4", "8", "16", "32", "64"})
     private int batchFrequency;
-    
+
     private ConnectableObservable<Integer> source;
     private Observable<Integer> observable;
     @Setup
@@ -99,13 +99,13 @@ public void setup() {
         source = src.publish();
         observable = async ? source.observeOn(Schedulers.computation()) : source;
     }
-    
+
     @Benchmark
-    public void benchmark(Blackhole bh) throws InterruptedException, 
+    public void benchmark(Blackhole bh) throws InterruptedException,
             TimeoutException, BrokenBarrierException {
         CountDownLatch completion = null;
         int cc = childCount;
-        
+
         if (cc > 0) {
             completion = new CountDownLatch(cc);
             Observable<Integer> o = observable;
@@ -113,9 +113,9 @@ public void benchmark(Blackhole bh) throws InterruptedException,
                 o.subscribe(new SharedLatchObserver(completion, batchFrequency, bh));
             }
         }
-        
+
         Subscription s = source.connect();
-        
+
         if (completion != null && !completion.await(2, TimeUnit.SECONDS)) {
             throw new RuntimeException("Source hung!");
         }
diff --git a/src/perf/java/rx/operators/OperatorRangePerf.java b/src/perf/java/rx/operators/OperatorRangePerf.java
index 52fd0af7ff..53e06a0c94 100644
--- a/src/perf/java/rx/operators/OperatorRangePerf.java
+++ b/src/perf/java/rx/operators/OperatorRangePerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -54,7 +54,7 @@ public Subscriber<Integer> newSubscriber() {
                 public void onStart() {
                     request(size);
                 }
-                
+
                 @Override
                 public void onCompleted() {
 
diff --git a/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java b/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
index dd41da53cc..3b54689c53 100644
--- a/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
+++ b/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
@@ -38,15 +38,15 @@ public int getSize() {
         }
 
     }
-    
+
     @Benchmark
     public void takeLastOneUsingTakeLast(Input input) {
        input.observable.lift(TAKE_LAST).subscribe(input.observer);
     }
-    
+
     @Benchmark
     public void takeLastOneUsingTakeLastOne(Input input) {
        Observable.create(new OnSubscribeTakeLastOne<Integer>(input.observable)).subscribe(input.observer);
     }
-    
+
 }
diff --git a/src/perf/java/rx/operators/RedoPerf.java b/src/perf/java/rx/operators/RedoPerf.java
index 2c5dc7f491..6878790762 100644
--- a/src/perf/java/rx/operators/RedoPerf.java
+++ b/src/perf/java/rx/operators/RedoPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -47,68 +47,68 @@
 public class RedoPerf {
     @Param({"1,1", "1,1000", "1,1000000", "1000,1", "1000,1000", "1000000,1"})
     public String params;
-    
+
     public int len;
     public int repeat;
-    
+
     Observable<Integer> sourceRepeating;
-    
+
     Observable<Integer> sourceRetrying;
-    
+
     Observable<Integer> redoRepeating;
-    
+
     Observable<Integer> redoRetrying;
 
     Observable<Integer> baseline;
-    
+
     @SuppressWarnings({ "rawtypes", "unchecked" })
     @Setup
     public void setup() {
         String[] ps = params.split(",");
         len = Integer.parseInt(ps[0]);
-        repeat = Integer.parseInt(ps[1]);        
-    
+        repeat = Integer.parseInt(ps[1]);
+
         Integer[] values = new Integer[len];
         Arrays.fill(values, 777);
-        
+
         Observable<Integer> source = Observable.from(values);
-        
+
         Observable<Integer> error = source.concatWith(Observable.<Integer>error(new RuntimeException()));
-        
+
         Integer[] values2 = new Integer[len * repeat];
         Arrays.fill(values2, 777);
-        
-        baseline = Observable.from(values2); 
-        
+
+        baseline = Observable.from(values2);
+
         sourceRepeating = source.repeat(repeat);
-        
+
         sourceRetrying = error.retry(repeat);
-        
+
         redoRepeating = source.repeatWhen((Func1)UtilityFunctions.identity()).take(len * repeat);
 
         redoRetrying = error.retryWhen((Func1)UtilityFunctions.identity()).take(len * repeat);
     }
-    
+
     @Benchmark
     public void baseline(Blackhole bh) {
         baseline.subscribe(new LatchedObserver<Integer>(bh));
     }
-    
+
     @Benchmark
     public void repeatCounted(Blackhole bh) {
         sourceRepeating.subscribe(new LatchedObserver<Integer>(bh));
     }
-    
+
     @Benchmark
     public void retryCounted(Blackhole bh) {
         sourceRetrying.subscribe(new LatchedObserver<Integer>(bh));
     }
-    
+
     @Benchmark
     public void repeatWhen(Blackhole bh) {
         redoRepeating.subscribe(new LatchedObserver<Integer>(bh));
     }
-    
+
     @Benchmark
     public void retryWhen(Blackhole bh) {
         redoRetrying.subscribe(new LatchedObserver<Integer>(bh));
diff --git a/src/perf/java/rx/operators/ZipPerf.java b/src/perf/java/rx/operators/ZipPerf.java
index 9ded231790..36608aea53 100644
--- a/src/perf/java/rx/operators/ZipPerf.java
+++ b/src/perf/java/rx/operators/ZipPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -45,41 +45,41 @@
 @OutputTimeUnit(TimeUnit.SECONDS)
 @State(Scope.Thread)
 public class ZipPerf {
-    
+
     @Param({"1", "1000", "1000000"})
     public int firstLen;
     @Param({"1", "1000", "1000000"})
     public int secondLen;
-    
+
     Observable<Integer> baseline;
-    
+
     Observable<Integer> bothSync;
     Observable<Integer> firstSync;
     Observable<Integer> secondSync;
     Observable<Integer> bothAsync;
-    
+
     boolean small;
-    
+
     @Setup
     public void setup() {
         Integer[] array1 = new Integer[firstLen];
         Arrays.fill(array1, 777);
         Integer[] array2 = new Integer[secondLen];
         Arrays.fill(array2, 777);
-        
+
         baseline = Observable.from(firstLen < secondLen? array2 : array1);
-    
+
         Observable<Integer> o1 = Observable.from(array1);
-        
+
         Observable<Integer> o2 = Observable.from(array2);
-        
+
         Func2<Integer, Integer, Integer> plus = new Func2<Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer a, Integer b) {
                 return a + b;
             }
         };
-        
+
         bothSync = Observable.zip(o1, o2, plus);
 
         firstSync = Observable.zip(o1, o2.subscribeOn(Schedulers.computation()), plus);
@@ -87,10 +87,10 @@ public Integer call(Integer a, Integer b) {
         secondSync = Observable.zip(o1.subscribeOn(Schedulers.computation()), o2, plus);
 
         bothAsync = Observable.zip(o1.subscribeOn(Schedulers.computation()), o2.subscribeOn(Schedulers.computation()), plus);
-    
+
         small = Math.min(firstLen, secondLen) < 100;
     }
-    
+
     @Benchmark
     public void baseline(Blackhole bh) {
         baseline.subscribe(new LatchedObserver<Integer>(bh));
@@ -105,7 +105,7 @@ public void syncSync(Blackhole bh) {
     public void syncAsync(Blackhole bh) throws Exception {
         LatchedObserver<Integer> o = new LatchedObserver<Integer>(bh);
         firstSync.subscribe(o);
-        
+
         if (small) {
             while (o.latch.getCount() != 0);
         } else {
@@ -117,7 +117,7 @@ public void syncAsync(Blackhole bh) throws Exception {
     public void asyncSync(Blackhole bh) throws Exception {
         LatchedObserver<Integer> o = new LatchedObserver<Integer>(bh);
         secondSync.subscribe(o);
-        
+
         if (small) {
             while (o.latch.getCount() != 0);
         } else {
@@ -129,7 +129,7 @@ public void asyncSync(Blackhole bh) throws Exception {
     public void asyncAsync(Blackhole bh) throws Exception {
         LatchedObserver<Integer> o = new LatchedObserver<Integer>(bh);
         bothAsync.subscribe(o);
-        
+
         if (small) {
             while (o.latch.getCount() != 0);
         } else {
diff --git a/src/perf/java/rx/subjects/PublishSubjectPerf.java b/src/perf/java/rx/subjects/PublishSubjectPerf.java
index 6c95d0f64e..b5dd15c7a1 100644
--- a/src/perf/java/rx/subjects/PublishSubjectPerf.java
+++ b/src/perf/java/rx/subjects/PublishSubjectPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -34,29 +34,29 @@
 @OutputTimeUnit(TimeUnit.SECONDS)
 @State(Scope.Thread)
 public class PublishSubjectPerf {
-    
+
     @Param({ "1", "2", "4", "8"})
     public int subscribers;
-    
+
     @Param({ "1", "1000", "1000000"})
     public int count;
-    
+
     @Benchmark
     public Object benchmark(Blackhole bh) {
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         int s = subscribers;
         for (int i = 0; i < s; i++) {
             ps.subscribe(new LatchedObserver<Integer>(bh));
         }
-        
+
         int c = count;
         for (int i = 0; i < c; i++) {
             ps.onNext(777);
         }
-        
+
         ps.onCompleted();
-        
+
         return ps;
     }
 }
diff --git a/src/perf/java/rx/subjects/ReplaySubjectPerf.java b/src/perf/java/rx/subjects/ReplaySubjectPerf.java
index 5d463efb53..6bd042dbd6 100644
--- a/src/perf/java/rx/subjects/ReplaySubjectPerf.java
+++ b/src/perf/java/rx/subjects/ReplaySubjectPerf.java
@@ -70,11 +70,11 @@ public void onNext(Object o) {
                 sum.incrementAndGet();
             }
         });
-        
+
         for (int i = 0; i < input.nextRuns; i++) {
             subject.onNext("Response");
         }
-        
+
         subject.onCompleted();
         latch.await();
         bh.consume(sum);
@@ -97,7 +97,7 @@ private void subscribeAfterEvents(ReplaySubject<Object> subject, final Input inp
         for (int i = 0; i < input.nextRuns; i++) {
             subject.onNext("Response");
         }
-        
+
         subject.onCompleted();
 
         subject.subscribe(new Observer<Object>() {
diff --git a/src/perf/java/rx/subscriptions/CompositeSubscriptionConcurrentPerf.java b/src/perf/java/rx/subscriptions/CompositeSubscriptionConcurrentPerf.java
index 0c2eee5796..fce4625e21 100644
--- a/src/perf/java/rx/subscriptions/CompositeSubscriptionConcurrentPerf.java
+++ b/src/perf/java/rx/subscriptions/CompositeSubscriptionConcurrentPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -46,11 +46,11 @@
 public class CompositeSubscriptionConcurrentPerf {
     @Param({ "1", "1000", "100000" })
     public int loop;
-    
+
     public final CompositeSubscription csub = new CompositeSubscription();
     @Param({ "1", "5", "10", "20" })
     public int count;
-    
+
     public Subscription[] values;
     @Setup
     public void setup() {
@@ -63,7 +63,7 @@ public boolean isUnsubscribed() {
                 }
                 @Override
                 public void unsubscribe() {
-                    
+
                 }
             };
         }
@@ -75,7 +75,7 @@ public void unsubscribe() {
     public void addRemoveT1() {
         CompositeSubscription csub = this.csub;
         Subscription[] values = this.values;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -91,7 +91,7 @@ public void addRemoveT1() {
     public void addRemoveT2() {
         CompositeSubscription csub = this.csub;
         Subscription[] values = this.values;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -108,7 +108,7 @@ public void addRemoveHalfT1() {
         CompositeSubscription csub = this.csub;
         Subscription[] values = this.values;
         int n = values.length;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = n / 2 - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -125,7 +125,7 @@ public void addRemoveHalfT2() {
         CompositeSubscription csub = this.csub;
         Subscription[] values = this.values;
         int n = values.length;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = n - 1; j >= n / 2; j--) {
                 csub.add(values[j]);
@@ -141,7 +141,7 @@ public void addRemoveHalfT2() {
     public void addClearT1() {
         CompositeSubscription csub = this.csub;
         Subscription[] values = this.values;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -155,7 +155,7 @@ public void addClearT1() {
     public void addClearT2() {
         CompositeSubscription csub = this.csub;
         Subscription[] values = this.values;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -172,7 +172,7 @@ public void addClearHalfT1() {
         CompositeSubscription csub = this.csub;
         Subscription[] values = this.values;
         int n = values.length;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = n / 2 - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -187,7 +187,7 @@ public void addClearHalfT2() {
         CompositeSubscription csub = this.csub;
         Subscription[] values = this.values;
         int n = values.length;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = n - 1; j >= n / 2; j--) {
                 csub.add(values[j]);
diff --git a/src/perf/java/rx/subscriptions/CompositeSubscriptionPerf.java b/src/perf/java/rx/subscriptions/CompositeSubscriptionPerf.java
index bbbd8f1b63..d49bfe1d0b 100644
--- a/src/perf/java/rx/subscriptions/CompositeSubscriptionPerf.java
+++ b/src/perf/java/rx/subscriptions/CompositeSubscriptionPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -39,9 +39,9 @@ public static class TheState {
         public int loop;
         @Param({ "1", "5", "10", "100" })
         public int count;
-        
+
         public final CompositeSubscription csub = new CompositeSubscription();
-        
+
         public Subscription[] values;
         @Setup
         public void setup() {
@@ -54,7 +54,7 @@ public boolean isUnsubscribed() {
                     }
                     @Override
                     public void unsubscribe() {
-                        
+
                     }
                 };
             }
@@ -64,7 +64,7 @@ public void unsubscribe() {
     public void addRemove(TheState state) {
         CompositeSubscription csub = state.csub;
         Subscription[] values = state.values;
-        
+
         for (int i = state.loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -78,7 +78,7 @@ public void addRemove(TheState state) {
     public void addRemoveLocal(TheState state, Blackhole bh) {
         CompositeSubscription csub = new CompositeSubscription();
         Subscription[] values = state.values;
-        
+
         for (int i = state.loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -87,14 +87,14 @@ public void addRemoveLocal(TheState state, Blackhole bh) {
                 csub.remove(values[j]);
             }
         }
-        
+
         bh.consume(csub);
     }
     @Benchmark
     public void addClear(TheState state) {
         CompositeSubscription csub = state.csub;
         Subscription[] values = state.values;
-        
+
         for (int i = state.loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -106,7 +106,7 @@ public void addClear(TheState state) {
     public void addClearLocal(TheState state, Blackhole bh) {
         CompositeSubscription csub = new CompositeSubscription();
         Subscription[] values = state.values;
-        
+
         for (int i = state.loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
diff --git a/src/perf/java/rx/subscriptions/MultipleAssignmentSubscriptionPerf.java b/src/perf/java/rx/subscriptions/MultipleAssignmentSubscriptionPerf.java
index b45a1c4c83..da48bc1429 100644
--- a/src/perf/java/rx/subscriptions/MultipleAssignmentSubscriptionPerf.java
+++ b/src/perf/java/rx/subscriptions/MultipleAssignmentSubscriptionPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -39,9 +39,9 @@ public static class TheState {
         public int loop;
         @Param({ "1", "5", "10", "100" })
         public int count;
-        
+
         public final MultipleAssignmentSubscription csub = new MultipleAssignmentSubscription();
-        
+
         public Subscription[] values;
         @Setup
         public void setup() {
@@ -54,7 +54,7 @@ public boolean isUnsubscribed() {
                     }
                     @Override
                     public void unsubscribe() {
-                        
+
                     }
                 };
             }
@@ -64,7 +64,7 @@ public void unsubscribe() {
     public void add(TheState state) {
         MultipleAssignmentSubscription csub = state.csub;
         Subscription[] values = state.values;
-        
+
         for (int i = state.loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.set(values[j]);
@@ -75,7 +75,7 @@ public void add(TheState state) {
     public void addLocal(TheState state, Blackhole bh) {
         MultipleAssignmentSubscription csub = new MultipleAssignmentSubscription();
         Subscription[] values = state.values;
-        
+
         for (int i = state.loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.set(values[j]);
diff --git a/src/perf/java/rx/subscriptions/SerialSubscriptionPerf.java b/src/perf/java/rx/subscriptions/SerialSubscriptionPerf.java
index 5f6a275b00..32a820f931 100644
--- a/src/perf/java/rx/subscriptions/SerialSubscriptionPerf.java
+++ b/src/perf/java/rx/subscriptions/SerialSubscriptionPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -39,9 +39,9 @@ public static class TheState {
         public int loop;
         @Param({ "1", "5", "10", "100" })
         public int count;
-        
+
         public final SerialSubscription csub = new SerialSubscription();
-        
+
         public Subscription[] values;
         @Setup
         public void setup() {
@@ -54,7 +54,7 @@ public boolean isUnsubscribed() {
                     }
                     @Override
                     public void unsubscribe() {
-                        
+
                     }
                 };
             }
@@ -64,7 +64,7 @@ public void unsubscribe() {
     public void add(TheState state) {
         SerialSubscription csub = state.csub;
         Subscription[] values = state.values;
-        
+
         for (int i = state.loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.set(values[j]);
@@ -75,7 +75,7 @@ public void add(TheState state) {
     public void addLocal(TheState state, Blackhole bh) {
         SerialSubscription csub = new SerialSubscription();
         Subscription[] values = state.values;
-        
+
         for (int i = state.loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.set(values[j]);
diff --git a/src/perf/java/rx/subscriptions/SubscriptionListConcurrentPerf.java b/src/perf/java/rx/subscriptions/SubscriptionListConcurrentPerf.java
index 93c7438f2c..b43d6222d3 100644
--- a/src/perf/java/rx/subscriptions/SubscriptionListConcurrentPerf.java
+++ b/src/perf/java/rx/subscriptions/SubscriptionListConcurrentPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -47,11 +47,11 @@
 public class SubscriptionListConcurrentPerf {
     @Param({ "1", "1000", "100000" })
     public int loop;
-    
+
     public final SubscriptionList csub = new SubscriptionList();
     @Param({ "1", "5", "10", "20" })
     public int count;
-    
+
     public Subscription[] values;
     @Setup
     public void setup() {
@@ -64,7 +64,7 @@ public boolean isUnsubscribed() {
                 }
                 @Override
                 public void unsubscribe() {
-                    
+
                 }
             };
         }
@@ -76,7 +76,7 @@ public void unsubscribe() {
     public void addClearT1() {
         SubscriptionList csub = this.csub;
         Subscription[] values = this.values;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -90,7 +90,7 @@ public void addClearT1() {
     public void addClearT2() {
         SubscriptionList csub = this.csub;
         Subscription[] values = this.values;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -105,7 +105,7 @@ public void addClearHalfT1() {
         SubscriptionList csub = this.csub;
         Subscription[] values = this.values;
         int n = values.length;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = n / 2 - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -120,7 +120,7 @@ public void addRemoveHalfT2() {
         SubscriptionList csub = this.csub;
         Subscription[] values = this.values;
         int n = values.length;
-        
+
         for (int i = loop; i > 0; i--) {
             for (int j = n - 1; j >= n / 2; j--) {
                 csub.add(values[j]);
diff --git a/src/perf/java/rx/subscriptions/SubscriptionListPerf.java b/src/perf/java/rx/subscriptions/SubscriptionListPerf.java
index ca2240275e..9947457d73 100644
--- a/src/perf/java/rx/subscriptions/SubscriptionListPerf.java
+++ b/src/perf/java/rx/subscriptions/SubscriptionListPerf.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -40,9 +40,9 @@ public static class TheState {
         public int loop;
         @Param({ "1", "5", "10", "100" })
         public int count;
-        
+
         public final SubscriptionList csub = new SubscriptionList();
-        
+
         public Subscription[] values;
         @Setup
         public void setup() {
@@ -55,7 +55,7 @@ public boolean isUnsubscribed() {
                     }
                     @Override
                     public void unsubscribe() {
-                        
+
                     }
                 };
             }
@@ -65,7 +65,7 @@ public void unsubscribe() {
     public void addClear(TheState state) {
         SubscriptionList csub = state.csub;
         Subscription[] values = state.values;
-        
+
         for (int i = state.loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
@@ -77,7 +77,7 @@ public void addClear(TheState state) {
     public void addClearLocal(TheState state, Blackhole bh) {
         SubscriptionList csub = new SubscriptionList();
         Subscription[] values = state.values;
-        
+
         for (int i = state.loop; i > 0; i--) {
             for (int j = values.length - 1; j >= 0; j--) {
                 csub.add(values[j]);
diff --git a/src/test/java/rx/BackpressureTests.java b/src/test/java/rx/BackpressureTests.java
index 96e0ba8acc..9556aff5e6 100644
--- a/src/test/java/rx/BackpressureTests.java
+++ b/src/test/java/rx/BackpressureTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -41,7 +41,7 @@ public class BackpressureTests {
     public void doAfterTest() {
         TestObstructionDetection.checkObstruction();
     }
-    
+
     @Test
     public void testObserveOn() {
         int NUM = (int) (RxRingBuffer.SIZE * 2.1);
@@ -133,7 +133,7 @@ public void testMergeAsyncThenObserveOnLoop() {
             int NUM = (int) (RxRingBuffer.SIZE * 4.1);
             AtomicInteger c1 = new AtomicInteger();
             AtomicInteger c2 = new AtomicInteger();
-            
+
             TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
             Observable<Integer> merged = Observable.merge(
                     incrementingIntegers(c1).subscribeOn(Schedulers.computation()),
@@ -146,7 +146,7 @@ public void testMergeAsyncThenObserveOnLoop() {
             assertEquals(NUM, ts.getOnNextEvents().size());
         }
     }
-    
+
     @Test
     public void testMergeAsyncThenObserveOn() {
         int NUM = (int) (RxRingBuffer.SIZE * 4.1);
@@ -445,7 +445,7 @@ public void testFirehoseFailsAsExpected() {
     public void testOnBackpressureDrop() {
         long t = System.currentTimeMillis();
         for (int i = 0; i < 100; i++) {
-            // stop the test if we are getting close to the timeout because slow machines 
+            // stop the test if we are getting close to the timeout because slow machines
             // may not get through 100 iterations
             if (System.currentTimeMillis() - t > TimeUnit.SECONDS.toMillis(9)) {
                 break;
@@ -494,7 +494,7 @@ public void call(Integer integer) {
             .map(SLOW_PASS_THRU).take(NUM).subscribe(ts);
             ts.awaitTerminalEvent();
             ts.assertNoErrors();
-            
+
             List<Integer> onNextEvents = ts.getOnNextEvents();
             Integer lastEvent = onNextEvents.get(NUM - 1);
             System.out.println(testName.getMethodName() + " => Received: " + onNextEvents.size() + " Passed: " + passCount.get() + " Dropped: " + dropCount.get() + "  Emitted: " + emitCount.get() + " Last value: " + lastEvent);
@@ -584,7 +584,7 @@ public Boolean call(Integer t1) {
 
     /**
      * A synchronous Observable that will emit incrementing integers as requested.
-     * 
+     *
      * @param counter
      * @return
      */
@@ -632,7 +632,7 @@ public void request(long n) {
 
     /**
      * Incrementing int without backpressure.
-     * 
+     *
      * @param counter
      * @return
      */
diff --git a/src/test/java/rx/CombineLatestTests.java b/src/test/java/rx/CombineLatestTests.java
index 1e032c2686..bd71831986 100644
--- a/src/test/java/rx/CombineLatestTests.java
+++ b/src/test/java/rx/CombineLatestTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 81b4c9524d..72941a7300 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -50,12 +50,12 @@ public Iterator<Completable> iterator() {
                 public boolean hasNext() {
                     return true;
                 }
-                
+
                 @Override
                 public Completable next() {
                     throw new TestException();
                 }
-                
+
                 @Override
                 public void remove() {
                     throw new UnsupportedOperationException();
@@ -75,12 +75,12 @@ public Iterator<Completable> iterator() {
                 public boolean hasNext() {
                     throw new TestException();
                 }
-                
+
                 @Override
                 public Completable next() {
                     return null;
                 }
-                
+
 
                 @Override
                 public void remove() {
@@ -96,7 +96,7 @@ public void remove() {
     static final class NormalCompletable extends AtomicInteger {
         /** */
         private static final long serialVersionUID = 7192337844700923752L;
-        
+
         public final Completable completable = Completable.create(new OnSubscribe() {
             @Override
             public void call(CompletableSubscriber s) {
@@ -105,7 +105,7 @@ public void call(CompletableSubscriber s) {
                 s.onCompleted();
             }
         });
-        
+
         /**
          * Asserts the given number of subscriptions happened.
          * @param n the expected number of subscriptions
@@ -122,7 +122,7 @@ public void assertSubscriptions(int n) {
     static final class ErrorCompletable extends AtomicInteger {
         /** */
         private static final long serialVersionUID = 7192337844700923752L;
-        
+
         public final Completable completable = Completable.create(new OnSubscribe() {
             @Override
             public void call(CompletableSubscriber s) {
@@ -131,7 +131,7 @@ public void call(CompletableSubscriber s) {
                 s.onError(new TestException());
             }
         });
-        
+
         /**
          * Asserts the given number of subscriptions happened.
          * @param n the expected number of subscriptions
@@ -150,73 +150,73 @@ public void assertSubscriptions(int n) {
     @Test(timeout = 5000)
     public void complete() {
         Completable c = Completable.complete();
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void concatNull() {
         Completable.concat((Completable[])null);
     }
-    
+
     @Test(timeout = 5000)
     public void concatEmpty() {
         Completable c = Completable.concat();
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void concatSingleSource() {
         Completable c = Completable.concat(normal.completable);
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void concatSingleSourceThrows() {
         Completable c = Completable.concat(error.completable);
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void concatMultipleSources() {
         Completable c = Completable.concat(normal.completable, normal.completable, normal.completable);
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(3);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void concatMultipleOneThrows() {
         Completable c = Completable.concat(normal.completable, error.completable, normal.completable);
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void concatMultipleOneIsNull() {
         Completable c = Completable.concat(normal.completable, null);
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void concatIterableEmpty() {
         Completable c = Completable.concat(Collections.<Completable>emptyList());
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void concatIterableNull() {
         Completable.concat((Iterable<Completable>)null);
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void concatIterableIteratorNull() {
         Completable c = Completable.concat(new Iterable<Completable>() {
@@ -225,49 +225,49 @@ public Iterator<Completable> iterator() {
                 return null;
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void concatIterableWithNull() {
         Completable c = Completable.concat(Arrays.asList(normal.completable, (Completable)null));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void concatIterableSingle() {
         Completable c = Completable.concat(Collections.singleton(normal.completable));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000)
     public void concatIterableMany() {
         Completable c = Completable.concat(Arrays.asList(normal.completable, normal.completable, normal.completable));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(3);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void concatIterableOneThrows() {
         Completable c = Completable.concat(Collections.singleton(error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void concatIterableManyOneThrows() {
         Completable c = Completable.concat(Arrays.asList(normal.completable, error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void concatIterableIterableThrows() {
         Completable c = Completable.concat(new Iterable<Completable>() {
@@ -276,70 +276,70 @@ public Iterator<Completable> iterator() {
                 throw new TestException();
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void concatIterableIteratorHasNextThrows() {
         Completable c = Completable.concat(new IterableIteratorHasNextThrows());
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void concatIterableIteratorNextThrows() {
         Completable c = Completable.concat(new IterableIteratorNextThrows());
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void concatObservableEmpty() {
         Completable c = Completable.concat(Observable.<Completable>empty());
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void concatObservableError() {
         Completable c = Completable.concat(Observable.<Completable>error(new TestException()));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void concatObservableSingle() {
         Completable c = Completable.concat(Observable.just(normal.completable));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void concatObservableSingleThrows() {
         Completable c = Completable.concat(Observable.just(error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void concatObservableMany() {
         Completable c = Completable.concat(Observable.just(normal.completable).repeat(3));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(3);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void concatObservableManyOneThrows() {
         Completable c = Completable.concat(Observable.just(normal.completable, error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void concatObservablePrefetch() {
         final List<Long> requested = new ArrayList<Long>();
@@ -352,15 +352,15 @@ public void call(Long v) {
                         requested.add(v);
                     }
                 });
-        
+
         Completable c = Completable.concat(cs, 5);
-        
+
         c.await();
-        
+
         // FIXME this request pattern looks odd because all 10 completions trigger 1 requests
         Assert.assertEquals(Arrays.asList(5L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L), requested);
     }
-    
+
     @Test
     public void andThen() {
         TestSubscriber<String> ts = new TestSubscriber<String>(0);
@@ -370,7 +370,7 @@ public void andThen() {
         ts.assertCompleted();
         ts.assertNoErrors();
     }
-    
+
     @Test
     public void andThenNever() {
         TestSubscriber<String> ts = new TestSubscriber<String>(0);
@@ -379,7 +379,7 @@ public void andThenNever() {
         ts.assertNoValues();
         ts.assertNoTerminalEvent();
     }
-    
+
     @Test
     public void andThenError() {
         TestSubscriber<String> ts = new TestSubscriber<String>(0);
@@ -404,7 +404,7 @@ public void call(Subscriber<? super String> s) {
         ts.assertError(e);
         Assert.assertFalse("Should not have subscribed to observable when completable errors", hasRun.get());
     }
-    
+
     @Test
     public void andThenSubscribeOn() {
         TestSubscriber<String> ts = new TestSubscriber<String>(0);
@@ -473,22 +473,22 @@ public void andThenSingleSubscribeOn() {
         ts.assertNoErrors();
         ts.assertUnsubscribed();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void createNull() {
         Completable.create((Completable.OnSubscribe)null);
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void createOnSubscribeThrowsNPE() {
         Completable c = Completable.create(new OnSubscribe() {
             @Override
             public void call(CompletableSubscriber s) { throw new NullPointerException(); }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void createOnSubscribeThrowsRuntimeException() {
         try {
@@ -498,9 +498,9 @@ public void call(CompletableSubscriber s) {
                     throw new TestException();
                 }
             });
-            
+
             c.await();
-            
+
             Assert.fail("Did not throw exception");
         } catch (NullPointerException ex) {
             if (!(ex.getCause() instanceof TestException)) {
@@ -509,7 +509,7 @@ public void call(CompletableSubscriber s) {
             }
         }
     }
-    
+
     @Test(timeout = 5000)
     public void defer() {
         Completable c = Completable.defer(new Func0<Completable>() {
@@ -518,19 +518,19 @@ public Completable call() {
                 return normal.completable;
             }
         });
-        
+
         normal.assertSubscriptions(0);
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void deferNull() {
         Completable.defer(null);
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void deferReturnsNull() {
         Completable c = Completable.defer(new Func0<Completable>() {
@@ -539,20 +539,20 @@ public Completable call() {
                 return null;
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void deferFunctionThrows() {
         Completable c = Completable.defer(new Func0<Completable>() {
             @Override
             public Completable call() { throw new TestException(); }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void deferErrorSource() {
         Completable c = Completable.defer(new Func0<Completable>() {
@@ -561,62 +561,62 @@ public Completable call() {
                 return error.completable;
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void errorNull() {
         Completable.error((Throwable)null);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void errorNormal() {
         Completable c = Completable.error(new TestException());
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void fromCallableNull() {
         Completable.fromCallable(null);
     }
-    
+
     @Test(timeout = 5000)
     public void fromCallableNormal() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = Completable.fromCallable(new Callable<Object>() {
             @Override
             public Object call() throws Exception {
                 return calls.getAndIncrement();
             }
         });
-        
+
         c.await();
-        
+
         Assert.assertEquals(1, calls.get());
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void fromCallableThrows() {
         Completable c = Completable.fromCallable(new Callable<Object>() {
             @Override
             public Object call() throws Exception { throw new TestException(); }
         });
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void fromObservableNull() {
         Completable.fromObservable(null);
     }
-    
+
     @Test(timeout = 5000)
     public void fromObservableEmpty() {
         Completable c = Completable.fromObservable(Observable.empty());
-        
+
         c.await();
     }
 
@@ -624,52 +624,52 @@ public void fromObservableEmpty() {
     public void fromObservableSome() {
         for (int n = 1; n < 10000; n *= 10) {
             Completable c = Completable.fromObservable(Observable.range(1, n));
-            
+
             c.await();
         }
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void fromObservableError() {
         Completable c = Completable.fromObservable(Observable.error(new TestException()));
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void fromFutureNull() {
         Completable.fromFuture(null);
     }
-    
+
     @Test(timeout = 5000)
     public void fromFutureNormal() {
         ExecutorService exec = Executors.newSingleThreadExecutor();
-        
+
         try {
             Completable c = Completable.fromFuture(exec.submit(new Runnable() {
                 @Override
-                public void run() { 
+                public void run() {
                     // no action
                 }
             }));
-            
+
             c.await();
         } finally {
             exec.shutdown();
         }
     }
-    
+
     @Test(timeout = 5000)
     public void fromFutureThrows() {
         ExecutorService exec = Executors.newSingleThreadExecutor();
-        
+
         Completable c = Completable.fromFuture(exec.submit(new Runnable() {
             @Override
-            public void run() { 
+            public void run() {
                 throw new TestException();
             }
         }));
-        
+
         try {
             c.await();
             Assert.fail("Failed to throw Exception");
@@ -682,120 +682,120 @@ public void run() {
             exec.shutdown();
         }
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void fromActionNull() {
         Completable.fromAction(null);
     }
-    
+
     @Test(timeout = 5000)
     public void fromActionNormal() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = Completable.fromAction(new Action0() {
             @Override
             public void call() {
                 calls.getAndIncrement();
             }
         });
-        
+
         c.await();
-        
+
         Assert.assertEquals(1, calls.get());
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void fromActionThrows() {
         Completable c = Completable.fromAction(new Action0() {
             @Override
             public void call() { throw new TestException(); }
         });
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void fromSingleNull() {
         Completable.fromSingle(null);
     }
-    
+
     @Test(timeout = 5000)
     public void fromSingleNormal() {
         Completable c = Completable.fromSingle(Single.just(1));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void fromSingleThrows() {
         Completable c = Completable.fromSingle(Single.error(new TestException()));
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void mergeNull() {
         Completable.merge((Completable[])null);
     }
-    
+
     @Test(timeout = 5000)
     public void mergeEmpty() {
         Completable c = Completable.merge();
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeSingleSource() {
         Completable c = Completable.merge(normal.completable);
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeSingleSourceThrows() {
         Completable c = Completable.merge(error.completable);
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeMultipleSources() {
         Completable c = Completable.merge(normal.completable, normal.completable, normal.completable);
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(3);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeMultipleOneThrows() {
         Completable c = Completable.merge(normal.completable, error.completable, normal.completable);
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeMultipleOneIsNull() {
         Completable c = Completable.merge(normal.completable, null);
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeIterableEmpty() {
         Completable c = Completable.merge(Collections.<Completable>emptyList());
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void mergeIterableNull() {
         Completable.merge((Iterable<Completable>)null);
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeIterableIteratorNull() {
         Completable c = Completable.merge(new Iterable<Completable>() {
@@ -804,49 +804,49 @@ public Iterator<Completable> iterator() {
                 return null;
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeIterableWithNull() {
         Completable c = Completable.merge(Arrays.asList(normal.completable, (Completable)null));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeIterableSingle() {
         Completable c = Completable.merge(Collections.singleton(normal.completable));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000)
     public void mergeIterableMany() {
         Completable c = Completable.merge(Arrays.asList(normal.completable, normal.completable, normal.completable));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(3);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeIterableOneThrows() {
         Completable c = Completable.merge(Collections.singleton(error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeIterableManyOneThrows() {
         Completable c = Completable.merge(Arrays.asList(normal.completable, error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void mergeIterableIterableThrows() {
         Completable c = Completable.merge(new Iterable<Completable>() {
@@ -855,70 +855,70 @@ public Iterator<Completable> iterator() {
                 throw new TestException();
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void mergeIterableIteratorHasNextThrows() {
         Completable c = Completable.merge(new IterableIteratorHasNextThrows());
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void mergeIterableIteratorNextThrows() {
         Completable c = Completable.merge(new IterableIteratorNextThrows());
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeObservableEmpty() {
         Completable c = Completable.merge(Observable.<Completable>empty());
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeObservableError() {
         Completable c = Completable.merge(Observable.<Completable>error(new TestException()));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeObservableSingle() {
         Completable c = Completable.merge(Observable.just(normal.completable));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeObservableSingleThrows() {
         Completable c = Completable.merge(Observable.just(error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeObservableMany() {
         Completable c = Completable.merge(Observable.just(normal.completable).repeat(3));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(3);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeObservableManyOneThrows() {
         Completable c = Completable.merge(Observable.just(normal.completable, error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeObservableMaxConcurrent() {
         final List<Long> requested = new ArrayList<Long>();
@@ -931,11 +931,11 @@ public void call(Long v) {
                         requested.add(v);
                     }
                 });
-        
+
         Completable c = Completable.merge(cs, 5);
-        
+
         c.await();
-        
+
         // FIXME this request pattern looks odd because all 10 completions trigger 1 requests
         Assert.assertEquals(Arrays.asList(5L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L), requested);
     }
@@ -944,69 +944,69 @@ public void call(Long v) {
     public void mergeDelayErrorNull() {
         Completable.mergeDelayError((Completable[])null);
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorEmpty() {
         Completable c = Completable.mergeDelayError();
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorSingleSource() {
         Completable c = Completable.mergeDelayError(normal.completable);
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeDelayErrorSingleSourceThrows() {
         Completable c = Completable.mergeDelayError(error.completable);
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorMultipleSources() {
         Completable c = Completable.mergeDelayError(normal.completable, normal.completable, normal.completable);
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(3);
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorMultipleOneThrows() {
         Completable c = Completable.mergeDelayError(normal.completable, error.completable, normal.completable);
-        
+
         try {
             c.await();
         } catch (TestException ex) {
             normal.assertSubscriptions(2);
         }
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeDelayErrorMultipleOneIsNull() {
         Completable c = Completable.mergeDelayError(normal.completable, null);
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorIterableEmpty() {
         Completable c = Completable.mergeDelayError(Collections.<Completable>emptyList());
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void mergeDelayErrorIterableNull() {
         Completable.mergeDelayError((Iterable<Completable>)null);
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeDelayErrorIterableIteratorNull() {
         Completable c = Completable.mergeDelayError(new Iterable<Completable>() {
@@ -1015,53 +1015,53 @@ public Iterator<Completable> iterator() {
                 return null;
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void mergeDelayErrorIterableWithNull() {
         Completable c = Completable.mergeDelayError(Arrays.asList(normal.completable, (Completable)null));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorIterableSingle() {
         Completable c = Completable.mergeDelayError(Collections.singleton(normal.completable));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorIterableMany() {
         Completable c = Completable.mergeDelayError(Arrays.asList(normal.completable, normal.completable, normal.completable));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(3);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeDelayErrorIterableOneThrows() {
         Completable c = Completable.mergeDelayError(Collections.singleton(error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorIterableManyOneThrows() {
         Completable c = Completable.mergeDelayError(Arrays.asList(normal.completable, error.completable, normal.completable));
-        
+
         try {
             c.await();
         } catch (TestException ex) {
             normal.assertSubscriptions(2);
         }
     }
-    
+
     @Test(expected = TestException.class)
     public void mergeDelayErrorIterableIterableThrows() {
         Completable c = Completable.mergeDelayError(new Iterable<Completable>() {
@@ -1070,70 +1070,70 @@ public Iterator<Completable> iterator() {
                 throw new TestException();
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void mergeDelayErrorIterableIteratorHasNextThrows() {
         Completable c = Completable.mergeDelayError(new IterableIteratorHasNextThrows());
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void mergeDelayErrorIterableIteratorNextThrows() {
         Completable c = Completable.mergeDelayError(new IterableIteratorNextThrows());
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorObservableEmpty() {
         Completable c = Completable.mergeDelayError(Observable.<Completable>empty());
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeDelayErrorObservableError() {
         Completable c = Completable.mergeDelayError(Observable.<Completable>error(new TestException()));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorObservableSingle() {
         Completable c = Completable.mergeDelayError(Observable.just(normal.completable));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeDelayErrorObservableSingleThrows() {
         Completable c = Completable.mergeDelayError(Observable.just(error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorObservableMany() {
         Completable c = Completable.mergeDelayError(Observable.just(normal.completable).repeat(3));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(3);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void mergeDelayErrorObservableManyOneThrows() {
         Completable c = Completable.mergeDelayError(Observable.just(normal.completable, error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void mergeDelayErrorObservableMaxConcurrent() {
         final List<Long> requested = new ArrayList<Long>();
@@ -1146,11 +1146,11 @@ public void call(Long v) {
                         requested.add(v);
                     }
                 });
-        
+
         Completable c = Completable.mergeDelayError(cs, 5);
-        
+
         c.await();
-        
+
         // FIXME this request pattern looks odd because all 10 completions trigger 1 requests
         Assert.assertEquals(Arrays.asList(5L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L), requested);
     }
@@ -1164,55 +1164,55 @@ public void never() {
             public void onSubscribe(Subscription d) {
                 onSubscribeCalled.set(true);
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 calls.getAndIncrement();
             }
-            
+
             @Override
             public void onCompleted() {
                 calls.getAndIncrement();
             }
         });
-        
+
         Assert.assertTrue("onSubscribe not called", onSubscribeCalled.get());
         Assert.assertEquals("There were calls to onXXX methods", 0, calls.get());
     }
-    
+
     @Test(timeout = 1500)
     public void timer() {
         Completable c = Completable.timer(500, TimeUnit.MILLISECONDS);
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 1500)
     public void timerNewThread() {
         Completable c = Completable.timer(500, TimeUnit.MILLISECONDS, Schedulers.newThread());
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void timerTestScheduler() {
         TestScheduler scheduler = Schedulers.test();
-        
+
         Completable c = Completable.timer(250, TimeUnit.MILLISECONDS, scheduler);
-        
+
         final AtomicInteger calls = new AtomicInteger();
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
             @Override
             public void onCompleted() {
                 calls.getAndIncrement();
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 RxJavaHooks.onError(e);
@@ -1220,61 +1220,61 @@ public void onError(Throwable e) {
         });
 
         scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
-        
+
         Assert.assertEquals(0, calls.get());
-        
+
         scheduler.advanceTimeBy(200, TimeUnit.MILLISECONDS);
-        
+
         Assert.assertEquals(1, calls.get());
     }
-    
+
     @Test(timeout = 2000)
     public void timerCancel() throws InterruptedException {
         Completable c = Completable.timer(250, TimeUnit.MILLISECONDS);
-        
+
         final MultipleAssignmentSubscription mad = new MultipleAssignmentSubscription();
         final AtomicInteger calls = new AtomicInteger();
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 mad.set(d);
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 calls.getAndIncrement();
             }
-            
+
             @Override
             public void onCompleted() {
                 calls.getAndIncrement();
             }
         });
-        
+
         Thread.sleep(100);
-        
+
         mad.unsubscribe();
-        
+
         Thread.sleep(200);
-        
+
         Assert.assertEquals(0, calls.get());
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void timerUnitNull() {
         Completable.timer(1, null);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void timerSchedulerNull() {
         Completable.timer(1, TimeUnit.SECONDS, null);
     }
-    
+
     @Test(timeout = 5000)
     public void usingNormalEager() {
         final AtomicInteger unsubscribe = new AtomicInteger();
-        
+
         Completable c = Completable.using(new Func0<Integer>() {
             @Override
             public Integer call() {
@@ -1291,36 +1291,36 @@ public void call(Integer d) {
                 unsubscribe.set(d);
             }
         });
-        
+
         final AtomicBoolean unsubscribedFirst = new AtomicBoolean();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 error.lazySet(e);
             }
-            
+
             @Override
             public void onCompleted() {
                 unsubscribedFirst.set(unsubscribe.get() != 0);
             }
         });
-        
+
         Assert.assertEquals(1, unsubscribe.get());
         Assert.assertTrue("Not unsubscribed first", unsubscribedFirst.get());
         Assert.assertNull(error.get());
     }
-    
+
     @Test(timeout = 5000)
     public void usingNormalLazy() {
         final AtomicInteger unsubscribe = new AtomicInteger();
-        
+
         Completable c = Completable.using(new Func0<Integer>() {
             @Override
             public Integer call() {
@@ -1337,36 +1337,36 @@ public void call(Integer d) {
                 unsubscribe.set(d);
             }
         }, false);
-        
+
         final AtomicBoolean unsubscribedFirst = new AtomicBoolean();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 error.lazySet(e);
             }
-            
+
             @Override
             public void onCompleted() {
                 unsubscribedFirst.set(unsubscribe.get() != 0);
             }
         });
-        
+
         Assert.assertEquals(1, unsubscribe.get());
         Assert.assertFalse("Disposed first", unsubscribedFirst.get());
         Assert.assertNull(error.get());
     }
-    
+
     @Test(timeout = 5000)
     public void usingErrorEager() {
         final AtomicInteger unsubscribe = new AtomicInteger();
-        
+
         Completable c = Completable.using(new Func0<Integer>() {
             @Override
             public Integer call() {
@@ -1383,36 +1383,36 @@ public void call(Integer d) {
                 unsubscribe.set(d);
             }
         });
-        
+
         final AtomicBoolean unsubscribedFirst = new AtomicBoolean();
         final AtomicBoolean complete = new AtomicBoolean();
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 unsubscribedFirst.set(unsubscribe.get() != 0);
             }
-            
+
             @Override
             public void onCompleted() {
                 complete.set(true);
             }
         });
-        
+
         Assert.assertEquals(1, unsubscribe.get());
         Assert.assertTrue("Not unsubscribed first", unsubscribedFirst.get());
         Assert.assertFalse(complete.get());
     }
-    
+
     @Test(timeout = 5000)
     public void usingErrorLazy() {
         final AtomicInteger unsubscribe = new AtomicInteger();
-        
+
         Completable c = Completable.using(new Func0<Integer>() {
             @Override
             public Integer call() {
@@ -1429,32 +1429,32 @@ public void call(Integer d) {
                 unsubscribe.set(d);
             }
         }, false);
-        
+
         final AtomicBoolean unsubscribedFirst = new AtomicBoolean();
         final AtomicBoolean complete = new AtomicBoolean();
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 unsubscribedFirst.set(unsubscribe.get() != 0);
             }
-            
+
             @Override
             public void onCompleted() {
                 complete.set(true);
             }
         });
-        
+
         Assert.assertEquals(1, unsubscribe.get());
         Assert.assertFalse("Disposed first", unsubscribedFirst.get());
         Assert.assertFalse(complete.get());
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void usingResourceSupplierNull() {
         Completable.using(null, new Func1<Object, Completable>() {
@@ -1497,10 +1497,10 @@ public Completable call(Object v) {
             @Override
             public void call(Object v) { }
         });
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void usingDisposeNull() {
         Completable.using(new Func0<Object>() {
@@ -1515,13 +1515,13 @@ public Completable call(Object v) {
             }
         }, null);
     }
-    
+
     @Test(expected = TestException.class)
     public void usingResourceThrows() {
         Completable c = Completable.using(new Func0<Object>() {
             @Override
             public Object call() { throw new TestException(); }
-        }, 
+        },
                 new Func1<Object, Completable>() {
                     @Override
                     public Completable call(Object v) {
@@ -1531,10 +1531,10 @@ public Completable call(Object v) {
                     @Override
                     public void call(Object v) { }
                 });
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void usingMapperThrows() {
         Completable c = Completable.using(new Func0<Object>() {
@@ -1542,7 +1542,7 @@ public void usingMapperThrows() {
             public Object call() {
                 return 1;
             }
-        }, 
+        },
                 new Func1<Object, Completable>() {
                     @Override
                     public Completable call(Object v) { throw new TestException(); }
@@ -1550,10 +1550,10 @@ public Object call() {
                     @Override
                     public void call(Object v) { }
                 });
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void usingDisposerThrows() {
         Completable c = Completable.using(new Func0<Object>() {
@@ -1561,7 +1561,7 @@ public void usingDisposerThrows() {
             public Object call() {
                 return 1;
             }
-        }, 
+        },
                 new Func1<Object, Completable>() {
                     @Override
                     public Completable call(Object v) {
@@ -1571,10 +1571,10 @@ public Completable call(Object v) {
                     @Override
                     public void call(Object v) { throw new TestException(); }
                 });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void composeNormal() {
         Completable c = error.completable.compose(new Transformer() {
@@ -1583,28 +1583,28 @@ public Completable call(Completable n) {
                 return n.onErrorComplete();
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void composeNull() {
         error.completable.compose(null);
     }
-    
+
     @Test(timeout = 5000)
     public void concatWithNormal() {
         Completable c = normal.completable.concatWith(normal.completable);
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(2);
     }
 
     @Test(timeout = 5000, expected = TestException.class)
     public void concatWithError() {
         Completable c = normal.completable.concatWith(error.completable);
-        
+
         c.await();
     }
 
@@ -1612,7 +1612,7 @@ public void concatWithError() {
     public void concatWithNull() {
         normal.completable.concatWith(null);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void delayUnitNull() {
         normal.completable.delay(1, null);
@@ -1622,60 +1622,60 @@ public void delayUnitNull() {
     public void delaySchedulerNull() {
         normal.completable.delay(1, TimeUnit.SECONDS, null);
     }
-    
+
     @Test(timeout = 5000)
     public void delayNormal() throws InterruptedException {
         Completable c = normal.completable.delay(250, TimeUnit.MILLISECONDS);
-        
+
         final AtomicBoolean done = new AtomicBoolean();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 error.set(e);
             }
-            
+
             @Override
             public void onCompleted() {
                 done.set(true);
             }
         });
-        
+
         Thread.sleep(100);
-        
+
         Assert.assertFalse("Already done", done.get());
-        
+
         Thread.sleep(200);
-        
+
         Assert.assertTrue("Not done", done.get());
-        
+
         Assert.assertNull(error.get());
     }
-    
+
     @Test(timeout = 5000)
     public void delayErrorImmediately() throws InterruptedException {
         Completable c = error.completable.delay(250, TimeUnit.MILLISECONDS);
-        
+
         final AtomicBoolean done = new AtomicBoolean();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 error.set(e);
             }
-            
+
             @Override
             public void onCompleted() {
                 done.set(true);
@@ -1686,126 +1686,126 @@ public void onCompleted() {
         Assert.assertFalse("Already done", done.get());
 
         Thread.sleep(100);
-        
+
         Assert.assertFalse("Already done", done.get());
-        
+
         Thread.sleep(200);
     }
-    
+
     @Test(timeout = 5000)
     public void delayErrorToo() throws InterruptedException {
         Completable c = error.completable.delay(250, TimeUnit.MILLISECONDS, Schedulers.computation(), true);
-        
+
         final AtomicBoolean done = new AtomicBoolean();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 error.set(e);
             }
-            
+
             @Override
             public void onCompleted() {
                 done.set(true);
             }
         });
-        
+
         Thread.sleep(100);
-        
+
         Assert.assertFalse("Already done", done.get());
         Assert.assertNull(error.get());
-        
+
         Thread.sleep(200);
-        
+
         Assert.assertFalse("Already done", done.get());
         Assert.assertTrue(error.get() instanceof TestException);
     }
-    
+
     @Test(timeout = 5000)
     public void doOnCompletedNormal() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = normal.completable.doOnCompleted(new Action0() {
             @Override
             public void call() {
                 calls.getAndIncrement();
             }
         });
-        
+
         c.await();
-        
+
         Assert.assertEquals(1, calls.get());
     }
-    
+
     @Test(timeout = 5000)
     public void doOnCompletedError() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = error.completable.doOnCompleted(new Action0() {
             @Override
             public void call() {
                 calls.getAndIncrement();
             }
         });
-        
+
         try {
             c.await();
             Assert.fail("Failed to throw TestException");
         } catch (TestException ex) {
             // expected
         }
-        
+
         Assert.assertEquals(0, calls.get());
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void doOnCompletedNull() {
         normal.completable.doOnCompleted(null);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void doOnCompletedThrows() {
         Completable c = normal.completable.doOnCompleted(new Action0() {
             @Override
             public void call() { throw new TestException(); }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void doOnDisposeNormalDoesntCall() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = normal.completable.doOnUnsubscribe(new Action0() {
             @Override
             public void call() {
                 calls.getAndIncrement();
             }
         });
-        
+
         c.await();
-        
+
         Assert.assertEquals(0, calls.get());
     }
-    
+
     @Test(timeout = 5000)
     public void doOnDisposeErrorDoesntCall() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = error.completable.doOnUnsubscribe(new Action0() {
             @Override
             public void call() {
                 calls.getAndIncrement();
             }
         });
-        
+
         try {
             c.await();
             Assert.fail("No exception thrown");
@@ -1814,117 +1814,117 @@ public void call() {
         }
         Assert.assertEquals(0, calls.get());
     }
-    
+
     @Test(timeout = 5000)
     public void doOnDisposeChildCancels() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = normal.completable.doOnUnsubscribe(new Action0() {
             @Override
             public void call() {
                 calls.getAndIncrement();
             }
         });
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 d.unsubscribe();
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 // ignored
             }
-            
+
             @Override
             public void onCompleted() {
                 // ignored
             }
         });
-        
+
         Assert.assertEquals(1, calls.get());
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void doOnDisposeNull() {
         normal.completable.doOnUnsubscribe(null);
     }
-    
+
     @Test(timeout = 5000)
     public void doOnDisposeThrows() {
         Completable c = normal.completable.doOnUnsubscribe(new Action0() {
             @Override
             public void call() { throw new TestException(); }
         });
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
                 d.unsubscribe();
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 // ignored
             }
-            
+
             @Override
             public void onCompleted() {
                 // ignored
             }
         });
     }
-    
+
     @Test(timeout = 5000)
     public void doOnErrorNoError() {
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        
+
         Completable c = normal.completable.doOnError(new Action1<Throwable>() {
             @Override
             public void call(Throwable e) {
                 error.set(e);
             }
         });
-        
+
         c.await();
-        
+
         Assert.assertNull(error.get());
     }
-    
+
     @Test(timeout = 5000)
     public void doOnErrorHasError() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
-        
+
         Completable c = error.completable.doOnError(new Action1<Throwable>() {
             @Override
             public void call(Throwable e) {
                 err.set(e);
             }
         });
-        
+
         try {
             c.await();
             Assert.fail("Did not throw exception");
         } catch (Throwable e) {
             // expected
         }
-        
+
         Assert.assertTrue(err.get() instanceof TestException);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void doOnErrorNull() {
         normal.completable.doOnError(null);
     }
-    
+
     @Test(timeout = 5000)
     public void doOnErrorThrows() {
         Completable c = error.completable.doOnError(new Action1<Throwable>() {
             @Override
             public void call(Throwable e) { throw new IllegalStateException(); }
         });
-        
+
         try {
             c.await();
         } catch (CompositeException ex) {
@@ -1934,148 +1934,148 @@ public void doOnErrorThrows() {
             Assert.assertTrue(a.get(1) instanceof IllegalStateException);
         }
     }
-    
+
     @Test(timeout = 5000)
     public void doOnSubscribeNormal() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = normal.completable.doOnSubscribe(new Action1<Subscription>() {
             @Override
             public void call(Subscription s) {
                 calls.getAndIncrement();
             }
         });
-        
+
         for (int i = 0; i < 10; i++) {
             c.await();
         }
-        
+
         Assert.assertEquals(10, calls.get());
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void doOnSubscribeNull() {
         normal.completable.doOnSubscribe(null);
     }
-    
+
     @Test(expected = TestException.class)
     public void doOnSubscribeThrows() {
         Completable c = normal.completable.doOnSubscribe(new Action1<Subscription>() {
             @Override
             public void call(Subscription d) { throw new TestException(); }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void doOnTerminateNormal() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = normal.completable.doOnTerminate(new Action0() {
             @Override
             public void call() {
                 calls.getAndIncrement();
             }
         });
-        
+
         c.await();
-        
+
         Assert.assertEquals(1, calls.get());
     }
-    
+
     @Test(timeout = 5000)
     public void doOnTerminateError() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = error.completable.doOnTerminate(new Action0() {
             @Override
             public void call() {
                 calls.getAndIncrement();
             }
         });
-        
+
         try {
             c.await();
             Assert.fail("Did dot throw exception");
         } catch (TestException ex) {
             // expected
         }
-        
+
         Assert.assertEquals(1, calls.get());
     }
-    
+
     @Test(timeout = 5000)
     public void doAfterTerminateNormal() {
         final AtomicBoolean doneAfter = new AtomicBoolean();
         final AtomicBoolean complete = new AtomicBoolean();
-        
+
         Completable c = normal.completable.doAfterTerminate(new Action0() {
             @Override
             public void call() {
                 doneAfter.set(complete.get());
             }
         });
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
 
             @Override
             public void onError(Throwable e) {
-                
+
             }
-            
+
             @Override
             public void onCompleted() {
                 complete.set(true);
             }
         });
-        
+
         c.await();
-        
+
         Assert.assertTrue("Not completed", complete.get());
         Assert.assertTrue("Closure called before onComplete", doneAfter.get());
     }
-    
+
     @Test(timeout = 5000)
     public void doAfterTerminateWithError() {
         final AtomicBoolean doneAfter = new AtomicBoolean();
-        
+
         Completable c = error.completable.doAfterTerminate(new Action0() {
             @Override
             public void call() {
                 doneAfter.set(true);
             }
         });
-        
+
         try {
             c.await();
             Assert.fail("Did not throw TestException");
         } catch (TestException ex) {
             // expected
         }
-        
+
         Assert.assertFalse("Closure called", doneAfter.get());
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void doAfterTerminateNull() {
         normal.completable.doAfterTerminate(null);
     }
-    
+
     @Test(timeout = 5000)
     public void getNormal() {
         Assert.assertNull(normal.completable.get());
     }
-    
+
     @Test(timeout = 5000)
     public void getError() {
         Assert.assertTrue(error.completable.get() instanceof TestException);
     }
-    
+
     @Test(timeout = 5000)
     public void getTimeout() {
         try {
@@ -2086,17 +2086,17 @@ public void getTimeout() {
             }
         }
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void getNullUnit() {
         normal.completable.get(1, null);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void liftNull() {
         normal.completable.lift((Completable.Operator)null);
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void liftReturnsNull() {
         Completable c = normal.completable.lift(new Operator() {
@@ -2105,7 +2105,7 @@ public CompletableSubscriber call(CompletableSubscriber v) {
                 return null;
             }
         });
-        
+
         c.await();
     }
 
@@ -2128,96 +2128,96 @@ public void onError(Throwable e) {
                 public void onSubscribe(Subscription d) {
                     v.onSubscribe(d);
                 }
-                
+
             };
         }
     }
     @Test(timeout = 5000, expected = TestException.class)
     public void liftOnCompleteError() {
         Completable c = normal.completable.lift(new CompletableOperatorSwap());
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void liftOnErrorComplete() {
         Completable c = error.completable.lift(new CompletableOperatorSwap());
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void mergeWithNull() {
         normal.completable.mergeWith(null);
     }
-    
+
     @Test(timeout = 5000)
     public void mergeWithNormal() {
         Completable c = normal.completable.mergeWith(normal.completable);
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(2);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void observeOnNull() {
         normal.completable.observeOn(null);
     }
-    
+
     @Test(timeout = 5000)
     public void observeOnNormal() throws InterruptedException {
         final AtomicReference<String> name = new AtomicReference<String>();
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
         final CountDownLatch cdl = new CountDownLatch(1);
-        
+
         Completable c = normal.completable.observeOn(Schedulers.computation());
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
             @Override
             public void onCompleted() {
                 name.set(Thread.currentThread().getName());
                 cdl.countDown();
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 err.set(e);
                 cdl.countDown();
             }
         });
-        
+
         cdl.await();
-        
+
         Assert.assertNull(err.get());
         Assert.assertTrue(name.get().startsWith("RxComputation"));
     }
-    
+
     @Test(timeout = 5000)
     public void observeOnError() throws InterruptedException {
         final AtomicReference<String> name = new AtomicReference<String>();
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
         final CountDownLatch cdl = new CountDownLatch(1);
-        
+
         Completable c = error.completable.observeOn(Schedulers.computation());
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
             @Override
             public void onCompleted() {
                 name.set(Thread.currentThread().getName());
                 cdl.countDown();
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 name.set(Thread.currentThread().getName());
@@ -2225,20 +2225,20 @@ public void onError(Throwable e) {
                 cdl.countDown();
             }
         });
-        
+
         cdl.await();
-        
+
         Assert.assertTrue(err.get() instanceof TestException);
         Assert.assertTrue(name.get().startsWith("RxComputation"));
     }
-    
+
     @Test(timeout = 5000)
     public void onErrorComplete() {
         Completable c = error.completable.onErrorComplete();
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void onErrorCompleteFalse() {
         Completable c = error.completable.onErrorComplete(new Func1<Throwable, Boolean>() {
@@ -2247,20 +2247,20 @@ public Boolean call(Throwable e) {
                 return e instanceof IllegalStateException;
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void onErrorCompleteNull() {
         error.completable.onErrorComplete(null);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void onErrorResumeNextNull() {
         error.completable.onErrorResumeNext(null);
     }
-    
+
     @Test(timeout = 5000)
     public void onErrorResumeNextFunctionReturnsNull() {
         Completable c = error.completable.onErrorResumeNext(new Func1<Throwable, Completable>() {
@@ -2269,7 +2269,7 @@ public Completable call(Throwable e) {
                 return null;
             }
         });
-        
+
         try {
             c.await();
             Assert.fail("Did not throw an exception");
@@ -2280,14 +2280,14 @@ public Completable call(Throwable e) {
             Assert.assertTrue(a.get(1) instanceof NullPointerException);
         }
     }
-    
+
     @Test(timeout = 5000)
     public void onErrorResumeNextFunctionThrows() {
         Completable c = error.completable.onErrorResumeNext(new Func1<Throwable, Completable>() {
             @Override
             public Completable call(Throwable e) { throw new TestException(); }
         });
-        
+
         try {
             c.await();
             Assert.fail("Did not throw an exception");
@@ -2298,7 +2298,7 @@ public void onErrorResumeNextFunctionThrows() {
             Assert.assertTrue(a.get(1) instanceof TestException);
         }
     }
-    
+
     @Test(timeout = 5000)
     public void onErrorResumeNextNormal() {
         Completable c = error.completable.onErrorResumeNext(new Func1<Throwable, Completable>() {
@@ -2307,10 +2307,10 @@ public Completable call(Throwable v) {
                 return normal.completable;
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void onErrorResumeNextError() {
         Completable c = error.completable.onErrorResumeNext(new Func1<Throwable, Completable>() {
@@ -2319,15 +2319,15 @@ public Completable call(Throwable v) {
                 return error.completable;
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 2000)
     public void repeatNormal() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = Completable.fromCallable(new Callable<Object>() {
             @Override
             public Object call() throws Exception {
@@ -2336,7 +2336,7 @@ public Object call() throws Exception {
                 return null;
             }
         }).repeat();
-        
+
         c.unsafeSubscribe(new CompletableSubscriber() {
             @Override
             public void onSubscribe(final Subscription d) {
@@ -2352,33 +2352,33 @@ public void call() {
                     }
                 }, 550, TimeUnit.MILLISECONDS);
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 err.set(e);
             }
-            
+
             @Override
             public void onCompleted() {
-                
+
             }
         });
-        
+
         Assert.assertEquals(6, calls.get());
         Assert.assertNull(err.get());
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void repeatError() {
         Completable c = error.completable.repeat();
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void repeat5Times() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = Completable.fromCallable(new Callable<Object>() {
             @Override
             public Object call() throws Exception {
@@ -2386,16 +2386,16 @@ public Object call() throws Exception {
                 return null;
             }
         }).repeat(5);
-        
+
         c.await();
-        
+
         Assert.assertEquals(5, calls.get());
     }
-    
+
     @Test(timeout = 5000)
     public void repeat1Time() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = Completable.fromCallable(new Callable<Object>() {
             @Override
             public Object call() throws Exception {
@@ -2403,16 +2403,16 @@ public Object call() throws Exception {
                 return null;
             }
         }).repeat(1);
-        
+
         c.await();
-        
+
         Assert.assertEquals(1, calls.get());
     }
-    
+
     @Test(timeout = 5000)
     public void repeat0Time() {
         final AtomicInteger calls = new AtomicInteger();
-        
+
         Completable c = Completable.fromCallable(new Callable<Object>() {
             @Override
             public Object call() throws Exception {
@@ -2420,30 +2420,30 @@ public Object call() throws Exception {
                 return null;
             }
         }).repeat(0);
-        
+
         c.await();
-        
+
         Assert.assertEquals(0, calls.get());
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void repeatWhenNull() {
         normal.completable.repeatWhen(null);
     }
-    
+
     @Test(timeout = 5000)
     public void retryNormal() {
         Completable c = normal.completable.retry();
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000)
     public void retry5Times() {
         final AtomicInteger calls = new AtomicInteger(5);
-        
+
         Completable c = Completable.fromAction(new Action0() {
             @Override
             public void call() {
@@ -2452,10 +2452,10 @@ public void call() {
                 }
             }
         }).retry();
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void retryBiPredicate5Times() {
         Completable c = error.completable.retry(new Func2<Integer, Throwable, Boolean>() {
@@ -2464,17 +2464,17 @@ public Boolean call(Integer n, Throwable e) {
                 return n < 5;
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void retryTimes5Error() {
         Completable c = error.completable.retry(5);
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void retryTimes5Normal() {
         final AtomicInteger calls = new AtomicInteger(5);
@@ -2487,15 +2487,15 @@ public void call() {
                 }
             }
         }).retry(5);
-        
+
         c.await();
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void retryNegativeTimes() {
         normal.completable.retry(-1);
     }
-    
+
     @Test(timeout = 5000)
     public void retryWhen5Times() {
         final AtomicInteger calls = new AtomicInteger(5);
@@ -2514,14 +2514,14 @@ public Observable<Object> call(Observable<? extends Throwable> o) {
                 return (Observable)o;
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void subscribe() throws InterruptedException {
         final AtomicBoolean complete = new AtomicBoolean();
-        
+
         Completable c = normal.completable
                 .delay(100, TimeUnit.MILLISECONDS)
                 .doOnCompleted(new Action0() {
@@ -2530,18 +2530,18 @@ public void call() {
                         complete.set(true);
                     }
                 });
-        
+
         c.subscribe();
-        
+
         Thread.sleep(150);
-        
+
         Assert.assertTrue("Not completed", complete.get());
     }
-    
+
     @Test(timeout = 5000)
     public void subscribeDispose() throws InterruptedException {
         final AtomicBoolean complete = new AtomicBoolean();
-        
+
         Completable c = normal.completable
                 .delay(200, TimeUnit.MILLISECONDS)
                 .doOnCompleted(new Action0() {
@@ -2550,18 +2550,18 @@ public void call() {
                         complete.set(true);
                     }
                 });
-        
+
         Subscription d = c.subscribe();
-        
+
         Thread.sleep(100);
-        
+
         d.unsubscribe();
-        
+
         Thread.sleep(150);
-        
+
         Assert.assertFalse("Completed", complete.get());
     }
-    
+
     @Test(timeout = 5000)
     public void subscribeTwoCallbacksNormal() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
@@ -2577,11 +2577,11 @@ public void call(Throwable e) {
                 err.set(e);
             }
         });
-        
+
         Assert.assertNull(err.get());
         Assert.assertTrue("Not completed", complete.get());
     }
-    
+
     @Test(timeout = 5000)
     public void subscribeTwoCallbacksError() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
@@ -2597,11 +2597,11 @@ public void call(Throwable e) {
                 err.set(e);
             }
         });
-        
+
         Assert.assertTrue(err.get() instanceof TestException);
         Assert.assertFalse("Not completed", complete.get());
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void subscribeTwoCallbacksFirstNull() {
         normal.completable.subscribe(null, new Action1<Throwable>() {
@@ -2609,7 +2609,7 @@ public void subscribeTwoCallbacksFirstNull() {
             public void call(Throwable throwable) {}
         });
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void subscribeTwoCallbacksSecondNull() {
         normal.completable.subscribe(new Action0() {
@@ -2617,7 +2617,7 @@ public void subscribeTwoCallbacksSecondNull() {
             public void call() { }
         }, null);
     }
-    
+
     @Test(timeout = 5000)
     public void subscribeTwoCallbacksCompleteThrows() {
         final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
@@ -2630,10 +2630,10 @@ public void call(Throwable e) {
                 err.set(e);
             }
         });
-        
+
         Assert.assertTrue(String.valueOf(err.get()), err.get() instanceof TestException);
     }
-    
+
     @Test(timeout = 5000)
     public void subscribeTwoCallbacksOnErrorThrows() {
         error.completable.subscribe(new Action0() {
@@ -2644,45 +2644,45 @@ public void call() { }
             public void call(Throwable e) { throw new TestException(); }
         });
     }
-    
+
     @Test(timeout = 5000)
     public void subscribeActionNormal() {
         final AtomicBoolean run = new AtomicBoolean();
-        
+
         normal.completable.subscribe(new Action0() {
             @Override
             public void call() {
                 run.set(true);
             }
         });
-        
+
         Assert.assertTrue("Not completed", run.get());
     }
 
     @Test(timeout = 5000)
     public void subscribeActionError() {
         final AtomicBoolean run = new AtomicBoolean();
-        
+
         error.completable.subscribe(new Action0() {
             @Override
             public void call() {
                 run.set(true);
             }
         });
-        
+
         Assert.assertFalse("Completed", run.get());
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void subscribeActionNull() {
         normal.completable.subscribe((Action0)null);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void subscribeSubscriberNull() {
         normal.completable.unsafeSubscribe((Subscriber<Object>)null);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void subscribeCompletableSubscriberNull() {
         normal.completable.unsafeSubscribe((CompletableSubscriber)null);
@@ -2691,9 +2691,9 @@ public void subscribeCompletableSubscriberNull() {
     @Test(timeout = 5000)
     public void subscribeSubscriberNormal() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
-        
+
         normal.completable.unsafeSubscribe(ts);
-        
+
         ts.assertCompleted();
         ts.assertNoValues();
         ts.assertNoErrors();
@@ -2702,57 +2702,57 @@ public void subscribeSubscriberNormal() {
     @Test(timeout = 5000)
     public void subscribeSubscriberError() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
-        
+
         error.completable.unsafeSubscribe(ts);
-        
+
         ts.assertNotCompleted();
         ts.assertNoValues();
         ts.assertError(TestException.class);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void subscribeOnNull() {
         normal.completable.subscribeOn(null);
     }
-    
+
     @Test(timeout = 5000)
     public void subscribeOnNormal() {
         final AtomicReference<String> name = new  AtomicReference<String>();
-        
+
         Completable c = Completable.create(new OnSubscribe() {
             @Override
-            public void call(CompletableSubscriber s) { 
+            public void call(CompletableSubscriber s) {
                 name.set(Thread.currentThread().getName());
                 s.onSubscribe(Subscriptions.unsubscribed());
                 s.onCompleted();
             }
         }).subscribeOn(Schedulers.computation());
-        
+
         c.await();
-        
+
         Assert.assertTrue(name.get().startsWith("RxComputation"));
     }
-    
+
     @Test(timeout = 5000)
     public void subscribeOnError() {
         final AtomicReference<String> name = new  AtomicReference<String>();
-        
+
         Completable c = Completable.create(new OnSubscribe() {
             @Override
-            public void call(CompletableSubscriber s) { 
+            public void call(CompletableSubscriber s) {
                 name.set(Thread.currentThread().getName());
                 s.onSubscribe(Subscriptions.unsubscribed());
                 s.onError(new TestException());
             }
         }).subscribeOn(Schedulers.computation());
-        
+
         try {
             c.await();
             Assert.fail("No exception thrown");
         } catch (TestException ex) {
             // expected
         }
-        
+
         Assert.assertTrue(name.get().startsWith("RxComputation"));
     }
 
@@ -2840,19 +2840,19 @@ public void call(Integer integer) {
     @Test(timeout = 5000)
     public void timeoutEmitError() {
         Throwable e = Completable.never().timeout(100, TimeUnit.MILLISECONDS).get();
-        
+
         Assert.assertTrue(e instanceof TimeoutException);
     }
-    
+
     @Test(timeout = 5000)
     public void timeoutSwitchNormal() {
         Completable c = Completable.never().timeout(100, TimeUnit.MILLISECONDS, normal.completable);
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000)
     public void timeoutTimerCancelled() throws InterruptedException {
         Completable c = Completable.fromCallable(new Callable<Object>() {
@@ -2862,14 +2862,14 @@ public Object call() throws Exception {
                 return null;
             }
         }).timeout(100, TimeUnit.MILLISECONDS, normal.completable);
-        
+
         c.await();
-        
+
         Thread.sleep(100);
-        
+
         normal.assertSubscriptions(0);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void timeoutUnitNull() {
         normal.completable.timeout(1, null);
@@ -2879,12 +2879,12 @@ public void timeoutUnitNull() {
     public void timeoutSchedulerNull() {
         normal.completable.timeout(1, TimeUnit.SECONDS, (Scheduler)null);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void timeoutOtherNull() {
         normal.completable.timeout(1, TimeUnit.SECONDS, (Completable)null);
     }
-    
+
     @Test(timeout = 5000)
     public void toNormal() {
         Observable<?> flow = normal.completable.to(new Func1<Completable, Observable<Object>>() {
@@ -2893,18 +2893,18 @@ public Observable<Object> call(Completable c) {
                 return c.toObservable();
             }
         });
-        
+
         flow.toBlocking().forEach(new Action1<Object>(){
-            @Override 
+            @Override
             public void call(Object e){ }
         });
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void toNull() {
         normal.completable.to(null);
     }
-    
+
     @Test(timeout = 5000)
     public void toObservableNormal() {
         normal.completable.toObservable().toBlocking().forEach(new Action1<Object>() {
@@ -2912,7 +2912,7 @@ public void toObservableNormal() {
             public void call(Object e) { }
         });
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void toObservableError() {
         error.completable.toObservable().toBlocking().forEach(new Action1<Object>() {
@@ -2923,10 +2923,10 @@ public void call(Object e) { }
 
     static <T> T get(Single<T> single) {
         final CountDownLatch cdl = new CountDownLatch(1);
-        
+
         final AtomicReference<T> v = new AtomicReference<T>();
         final AtomicReference<Throwable> e = new AtomicReference<Throwable>();
-        
+
         single.subscribe(new SingleSubscriber<T>() {
 
             @Override
@@ -2941,19 +2941,19 @@ public void onError(Throwable error) {
                 cdl.countDown();
             }
         });
-        
+
         try {
             cdl.await();
         } catch (InterruptedException ex) {
             Exceptions.propagate(ex);
         }
-        
+
         if (e.get() != null) {
             Exceptions.propagate(e.get());
         }
         return v.get();
     }
-    
+
     @Test(timeout = 5000)
     public void toSingleSupplierNormal() {
         int v = get(normal.completable.toSingle(new Func0<Integer>() {
@@ -2962,7 +2962,7 @@ public Integer call() {
                 return 1;
             }
         }));
-        
+
         Assert.assertEquals(1, v);
     }
 
@@ -2980,7 +2980,7 @@ public Object call() {
     public void toSingleSupplierNull() {
         normal.completable.toSingle(null);
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void toSingleSupplierReturnsNull() {
         get(normal.completable.toSingle(new Func0<Object>() {
@@ -3003,22 +3003,22 @@ public void toSingleSupplierThrows() {
     public void toSingleDefaultError() {
         get(error.completable.toSingleDefault(1));
     }
-    
+
     @Test(timeout = 5000)
     public void toSingleDefaultNormal() {
         Assert.assertEquals((Integer)1, get(normal.completable.toSingleDefault(1)));
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void toSingleDefaultNull() {
         normal.completable.toSingleDefault(null);
     }
-    
+
     @Test(timeout = 5000)
     public void unsubscribeOnNormal() throws InterruptedException {
         final AtomicReference<String> name = new AtomicReference<String>();
         final CountDownLatch cdl = new CountDownLatch(1);
-        
+
         normal.completable.delay(1, TimeUnit.SECONDS)
         .doOnUnsubscribe(new Action0() {
             @Override
@@ -3032,7 +3032,7 @@ public void call() {
             @Override
             public void onSubscribe(final Subscription d) {
                 final Scheduler.Worker w = Schedulers.io().createWorker();
-                
+
                 w.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -3044,23 +3044,23 @@ public void call() {
                     }
                 }, 100, TimeUnit.MILLISECONDS);
             }
-            
+
             @Override
             public void onError(Throwable e) {
-                
+
             }
-            
+
             @Override
             public void onCompleted() {
-                
+
             }
         });
-        
+
         cdl.await();
-        
+
         Assert.assertTrue(name.get().startsWith("RxComputation"));
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void ambArrayNull() {
         Completable.amb((Completable[])null);
@@ -3069,52 +3069,52 @@ public void ambArrayNull() {
     @Test(timeout = 5000)
     public void ambArrayEmpty() {
         Completable c = Completable.amb();
-                
+
         c.await();
     }
 
     @Test(timeout = 5000)
     public void ambArraySingleNormal() {
         Completable c = Completable.amb(normal.completable);
-                
+
         c.await();
     }
 
     @Test(timeout = 5000, expected = TestException.class)
     public void ambArraySingleError() {
         Completable c = Completable.amb(error.completable);
-                
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void ambArrayOneFires() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
-        
+
         Completable c1 = Completable.fromObservable(ps1);
 
         Completable c2 = Completable.fromObservable(ps2);
-        
+
         Completable c = Completable.amb(c1, c2);
-        
+
         final AtomicBoolean complete = new AtomicBoolean();
-        
+
         c.subscribe(new Action0() {
             @Override
             public void call() {
                 complete.set(true);
             }
         });
-        
+
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
         Assert.assertTrue("Second subject no subscribers", ps2.hasObservers());
-        
+
         ps1.onCompleted();
-        
+
         Assert.assertFalse("First subject has subscribers", ps1.hasObservers());
         Assert.assertFalse("Second subject has subscribers", ps2.hasObservers());
-        
+
         Assert.assertTrue("Not completed", complete.get());
     }
 
@@ -3122,15 +3122,15 @@ public void call() {
     public void ambArrayOneFiresError() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
-        
+
         Completable c1 = Completable.fromObservable(ps1);
 
         Completable c2 = Completable.fromObservable(ps2);
-        
+
         Completable c = Completable.amb(c1, c2);
-        
+
         final AtomicReference<Throwable> complete = new AtomicReference<Throwable>();
-        
+
         c.subscribe(new Action0() {
             @Override
             public void call() { }
@@ -3140,46 +3140,46 @@ public void call(Throwable e) {
                 complete.set(e);
             }
         });
-        
+
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
         Assert.assertTrue("Second subject no subscribers", ps2.hasObservers());
-        
+
         ps1.onError(new TestException());
-        
+
         Assert.assertFalse("First subject has subscribers", ps1.hasObservers());
         Assert.assertFalse("Second subject has subscribers", ps2.hasObservers());
-        
+
         Assert.assertTrue("Not completed", complete.get() instanceof TestException);
     }
-    
+
     @Test(timeout = 5000)
     public void ambArraySecondFires() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
-        
+
         Completable c1 = Completable.fromObservable(ps1);
 
         Completable c2 = Completable.fromObservable(ps2);
-        
+
         Completable c = Completable.amb(c1, c2);
-        
+
         final AtomicBoolean complete = new AtomicBoolean();
-        
+
         c.subscribe(new Action0() {
             @Override
             public void call() {
                 complete.set(true);
             }
         });
-        
+
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
         Assert.assertTrue("Second subject no subscribers", ps2.hasObservers());
-        
+
         ps2.onCompleted();
-        
+
         Assert.assertFalse("First subject has subscribers", ps1.hasObservers());
         Assert.assertFalse("Second subject has subscribers", ps2.hasObservers());
-        
+
         Assert.assertTrue("Not completed", complete.get());
     }
 
@@ -3187,15 +3187,15 @@ public void call() {
     public void ambArraySecondFiresError() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
-        
+
         Completable c1 = Completable.fromObservable(ps1);
 
         Completable c2 = Completable.fromObservable(ps2);
-        
+
         Completable c = Completable.amb(c1, c2);
-        
+
         final AtomicReference<Throwable> complete = new AtomicReference<Throwable>();
-        
+
         c.subscribe(new Action0() {
             @Override
             public void call() { }
@@ -3205,37 +3205,37 @@ public void call(Throwable e) {
                 complete.set(e);
             }
         });
-        
+
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
         Assert.assertTrue("Second subject no subscribers", ps2.hasObservers());
-        
+
         ps2.onError(new TestException());
-        
+
         Assert.assertFalse("First subject has subscribers", ps1.hasObservers());
         Assert.assertFalse("Second subject has subscribers", ps2.hasObservers());
-        
+
         Assert.assertTrue("Not completed", complete.get() instanceof TestException);
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void ambMultipleOneIsNull() {
         Completable c = Completable.amb(null, normal.completable);
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void ambIterableEmpty() {
         Completable c = Completable.amb(Collections.<Completable>emptyList());
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void ambIterableNull() {
         Completable.amb((Iterable<Completable>)null);
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void ambIterableIteratorNull() {
         Completable c = Completable.amb(new Iterable<Completable>() {
@@ -3244,49 +3244,49 @@ public Iterator<Completable> iterator() {
                 return null;
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = NullPointerException.class)
     public void ambIterableWithNull() {
         Completable c = Completable.amb(Arrays.asList(null, normal.completable));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000)
     public void ambIterableSingle() {
         Completable c = Completable.amb(Collections.singleton(normal.completable));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000)
     public void ambIterableMany() {
         Completable c = Completable.amb(Arrays.asList(normal.completable, normal.completable, normal.completable));
-        
+
         c.await();
-        
+
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void ambIterableOneThrows() {
         Completable c = Completable.amb(Collections.singleton(error.completable));
-        
+
         c.await();
     }
-    
+
     @Test(timeout = 5000, expected = TestException.class)
     public void ambIterableManyOneThrows() {
         Completable c = Completable.amb(Arrays.asList(error.completable, normal.completable));
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void ambIterableIterableThrows() {
         Completable c = Completable.amb(new Iterable<Completable>() {
@@ -3295,57 +3295,57 @@ public Iterator<Completable> iterator() {
                 throw new TestException();
             }
         });
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void ambIterableIteratorHasNextThrows() {
         Completable c = Completable.amb(new IterableIteratorHasNextThrows());
-        
+
         c.await();
     }
-    
+
     @Test(expected = TestException.class)
     public void ambIterableIteratorNextThrows() {
         Completable c = Completable.amb(new IterableIteratorNextThrows());
-        
+
         c.await();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void ambWithNull() {
         normal.completable.ambWith(null);
     }
-    
+
     @Test(timeout = 5000)
     public void ambWithArrayOneFires() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
-        
+
         Completable c1 = Completable.fromObservable(ps1);
 
         Completable c2 = Completable.fromObservable(ps2);
-        
+
         Completable c = c1.ambWith(c2);
-        
+
         final AtomicBoolean complete = new AtomicBoolean();
-        
+
         c.subscribe(new Action0() {
             @Override
             public void call() {
                 complete.set(true);
             }
         });
-        
+
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
         Assert.assertTrue("Second subject no subscribers", ps2.hasObservers());
-        
+
         ps1.onCompleted();
-        
+
         Assert.assertFalse("First subject has subscribers", ps1.hasObservers());
         Assert.assertFalse("Second subject has subscribers", ps2.hasObservers());
-        
+
         Assert.assertTrue("Not completed", complete.get());
     }
 
@@ -3353,15 +3353,15 @@ public void call() {
     public void ambWithArrayOneFiresError() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
-        
+
         Completable c1 = Completable.fromObservable(ps1);
 
         Completable c2 = Completable.fromObservable(ps2);
-        
+
         Completable c = c1.ambWith(c2);
-        
+
         final AtomicReference<Throwable> complete = new AtomicReference<Throwable>();
-        
+
         c.subscribe(new Action0() {
             @Override
             public void call() { }
@@ -3371,46 +3371,46 @@ public void call(Throwable e) {
                 complete.set(e);
             }
         });
-        
+
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
         Assert.assertTrue("Second subject no subscribers", ps2.hasObservers());
-        
+
         ps1.onError(new TestException());
-        
+
         Assert.assertFalse("First subject has subscribers", ps1.hasObservers());
         Assert.assertFalse("Second subject has subscribers", ps2.hasObservers());
-        
+
         Assert.assertTrue("Not completed", complete.get() instanceof TestException);
     }
-    
+
     @Test(timeout = 5000)
     public void ambWithArraySecondFires() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
-        
+
         Completable c1 = Completable.fromObservable(ps1);
 
         Completable c2 = Completable.fromObservable(ps2);
-        
+
         Completable c = c1.ambWith(c2);
-        
+
         final AtomicBoolean complete = new AtomicBoolean();
-        
+
         c.subscribe(new Action0() {
             @Override
             public void call() {
                 complete.set(true);
             }
         });
-        
+
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
         Assert.assertTrue("Second subject no subscribers", ps2.hasObservers());
-        
+
         ps2.onCompleted();
-        
+
         Assert.assertFalse("First subject has subscribers", ps1.hasObservers());
         Assert.assertFalse("Second subject has subscribers", ps2.hasObservers());
-        
+
         Assert.assertTrue("Not completed", complete.get());
     }
 
@@ -3418,15 +3418,15 @@ public void call() {
     public void ambWithArraySecondFiresError() {
         PublishSubject<Object> ps1 = PublishSubject.create();
         PublishSubject<Object> ps2 = PublishSubject.create();
-        
+
         Completable c1 = Completable.fromObservable(ps1);
 
         Completable c2 = Completable.fromObservable(ps2);
-        
+
         Completable c = c1.ambWith(c2);
-        
+
         final AtomicReference<Throwable> complete = new AtomicReference<Throwable>();
-        
+
         c.subscribe(new Action0() {
             @Override
             public void call() { }
@@ -3436,18 +3436,18 @@ public void call(Throwable e) {
                 complete.set(e);
             }
         });
-        
+
         Assert.assertTrue("First subject no subscribers", ps1.hasObservers());
         Assert.assertTrue("Second subject no subscribers", ps2.hasObservers());
-        
+
         ps2.onError(new TestException());
-        
+
         Assert.assertFalse("First subject has subscribers", ps1.hasObservers());
         Assert.assertFalse("Second subject has subscribers", ps2.hasObservers());
-        
+
         Assert.assertTrue("Not completed", complete.get() instanceof TestException);
     }
-    
+
     @Test(timeout = 5000)
     public void startWithCompletableNormal() {
         final AtomicBoolean run = new AtomicBoolean();
@@ -3459,17 +3459,17 @@ public Object call() throws Exception {
                         return null;
                     }
                 }));
-        
+
         c.await();
-        
+
         Assert.assertTrue("Did not start with other", run.get());
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000)
     public void startWithCompletableError() {
         Completable c = normal.completable.startWith(error.completable);
-        
+
         try {
             c.await();
             Assert.fail("Did not throw TestException");
@@ -3478,7 +3478,7 @@ public void startWithCompletableError() {
             error.assertSubscriptions(1);
         }
     }
-    
+
     @Test(timeout = 5000)
     public void startWithFlowableNormal() {
         final AtomicBoolean run = new AtomicBoolean();
@@ -3490,35 +3490,35 @@ public Object call() throws Exception {
                         return 1;
                     }
                 }));
-        
+
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
-        
+
         c.subscribe(ts);
-        
+
         Assert.assertTrue("Did not start with other", run.get());
         normal.assertSubscriptions(1);
-        
+
         ts.assertValue(1);
         ts.assertCompleted();
         ts.assertNoErrors();
     }
-    
+
     @Test(timeout = 5000)
     public void startWithFlowableError() {
         Observable<Object> c = normal.completable
                 .startWith(Observable.error(new TestException()));
-        
+
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
-        
+
         c.subscribe(ts);
-        
+
         normal.assertSubscriptions(0);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void startWithCompletableNull() {
         normal.completable.startWith((Completable)null);
@@ -3550,17 +3550,17 @@ public Object call() throws Exception {
                         return null;
                     }
                 }));
-        
+
         c.await();
-        
+
         Assert.assertFalse("Start with other", run.get());
         normal.assertSubscriptions(1);
     }
-    
+
     @Test(timeout = 5000)
     public void andThenCompletableError() {
         Completable c = normal.completable.andThen(error.completable);
-        
+
         try {
             c.await();
             Assert.fail("Did not throw TestException");
@@ -3569,7 +3569,7 @@ public void andThenCompletableError() {
             error.assertSubscriptions(1);
         }
     }
-    
+
     @Test(timeout = 5000)
     public void andThenFlowableNormal() {
         final AtomicBoolean run = new AtomicBoolean();
@@ -3581,42 +3581,42 @@ public Object call() throws Exception {
                         return 1;
                     }
                 }));
-        
+
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
-        
+
         c.subscribe(ts);
-        
+
         Assert.assertFalse("Start with other", run.get());
         normal.assertSubscriptions(1);
-        
+
         ts.assertValue(1);
         ts.assertCompleted();
         ts.assertNoErrors();
     }
-    
+
     @Test(timeout = 5000)
     public void andThenFlowableError() {
         Observable<Object> c = normal.completable
                 .andThen(Observable.error(new TestException()));
-        
+
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
-        
+
         c.subscribe(ts);
-        
+
         normal.assertSubscriptions(1);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void usingFactoryThrows() {
         @SuppressWarnings("unchecked")
         Action1<Integer> onDispose = mock(Action1.class);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Completable.using(new Func0<Integer>() {
             @Override
             public Integer call() {
@@ -3629,9 +3629,9 @@ public Completable call(Integer t) {
                 throw new TestException();
             }
         }, onDispose).unsafeSubscribe(ts);
-        
+
         verify(onDispose).call(1);
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(TestException.class);
@@ -3645,9 +3645,9 @@ public void call(Integer t) {
                 throw new TestException();
             }
         };
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Completable.using(new Func0<Integer>() {
             @Override
             public Integer call() {
@@ -3660,17 +3660,17 @@ public Completable call(Integer t) {
                 throw new TestException();
             }
         }, onDispose).unsafeSubscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(CompositeException.class);
-        
+
         CompositeException ex = (CompositeException)ts.getOnErrorEvents().get(0);
-        
+
         List<Throwable> listEx = ex.getExceptions();
-        
+
         assertEquals(2, listEx.size());
-        
+
         assertTrue(listEx.get(0).toString(), listEx.get(0) instanceof TestException);
         assertTrue(listEx.get(1).toString(), listEx.get(1) instanceof TestException);
     }
@@ -3679,9 +3679,9 @@ public Completable call(Integer t) {
     public void usingFactoryReturnsNull() {
         @SuppressWarnings("unchecked")
         Action1<Integer> onDispose = mock(Action1.class);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Completable.using(new Func0<Integer>() {
             @Override
             public Integer call() {
@@ -3694,9 +3694,9 @@ public Completable call(Integer t) {
                 return null;
             }
         }, onDispose).unsafeSubscribe(ts);
-        
+
         verify(onDispose).call(1);
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(NullPointerException.class);
@@ -3710,9 +3710,9 @@ public void call(Integer t) {
                 throw new TestException();
             }
         };
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Completable.using(new Func0<Integer>() {
             @Override
             public Integer call() {
@@ -3725,17 +3725,17 @@ public Completable call(Integer t) {
                 return null;
             }
         }, onDispose).unsafeSubscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(CompositeException.class);
-        
+
         CompositeException ex = (CompositeException)ts.getOnErrorEvents().get(0);
-        
+
         List<Throwable> listEx = ex.getExceptions();
-        
+
         assertEquals(2, listEx.size());
-        
+
         assertTrue(listEx.get(0).toString(), listEx.get(0) instanceof NullPointerException);
         assertTrue(listEx.get(1).toString(), listEx.get(1) instanceof TestException);
     }
@@ -3744,11 +3744,11 @@ public Completable call(Integer t) {
     public void subscribeReportsUnsubscribed() {
         PublishSubject<String> stringSubject = PublishSubject.create();
         Completable completable = stringSubject.toCompletable();
-        
+
         Subscription completableSubscription = completable.subscribe();
-        
+
         stringSubject.onCompleted();
-        
+
         assertTrue("Not unsubscribed?", completableSubscription.isUnsubscribed());
     }
 
@@ -3756,11 +3756,11 @@ public void subscribeReportsUnsubscribed() {
     public void subscribeReportsUnsubscribedOnError() {
         PublishSubject<String> stringSubject = PublishSubject.create();
         Completable completable = stringSubject.toCompletable();
-        
+
         Subscription completableSubscription = completable.subscribe();
-        
+
         stringSubject.onError(new TestException());
-        
+
         assertTrue("Not unsubscribed?", completableSubscription.isUnsubscribed());
     }
 
@@ -3768,11 +3768,11 @@ public void subscribeReportsUnsubscribedOnError() {
     public void subscribeActionReportsUnsubscribed() {
         PublishSubject<String> stringSubject = PublishSubject.create();
         Completable completable = stringSubject.toCompletable();
-        
+
         Subscription completableSubscription = completable.subscribe(Actions.empty());
-        
+
         stringSubject.onCompleted();
-        
+
         assertTrue("Not unsubscribed?", completableSubscription.isUnsubscribed());
     }
 
@@ -3780,7 +3780,7 @@ public void subscribeActionReportsUnsubscribed() {
     public void subscribeActionReportsUnsubscribedAfter() {
         PublishSubject<String> stringSubject = PublishSubject.create();
         Completable completable = stringSubject.toCompletable();
-        
+
         final AtomicReference<Subscription> subscriptionRef = new AtomicReference<Subscription>();
         Subscription completableSubscription = completable.subscribe(new Action0() {
             @Override
@@ -3791,9 +3791,9 @@ public void call() {
             }
         });
         subscriptionRef.set(completableSubscription);
-        
+
         stringSubject.onCompleted();
-        
+
         assertTrue("Not unsubscribed?", completableSubscription.isUnsubscribed());
         assertNotNull("Unsubscribed before the call to onCompleted", subscriptionRef.get());
     }
@@ -3802,11 +3802,11 @@ public void call() {
     public void subscribeActionReportsUnsubscribedOnError() {
         PublishSubject<String> stringSubject = PublishSubject.create();
         Completable completable = stringSubject.toCompletable();
-        
+
         Subscription completableSubscription = completable.subscribe(Actions.empty());
-        
+
         stringSubject.onError(new TestException());
-        
+
         assertTrue("Not unsubscribed?", completableSubscription.isUnsubscribed());
     }
 
@@ -3814,11 +3814,11 @@ public void subscribeActionReportsUnsubscribedOnError() {
     public void subscribeAction2ReportsUnsubscribed() {
         PublishSubject<String> stringSubject = PublishSubject.create();
         Completable completable = stringSubject.toCompletable();
-        
+
         Subscription completableSubscription = completable.subscribe(Actions.empty(), Actions.empty());
-        
+
         stringSubject.onCompleted();
-        
+
         assertTrue("Not unsubscribed?", completableSubscription.isUnsubscribed());
     }
 
@@ -3826,11 +3826,11 @@ public void subscribeAction2ReportsUnsubscribed() {
     public void subscribeAction2ReportsUnsubscribedOnError() {
         PublishSubject<String> stringSubject = PublishSubject.create();
         Completable completable = stringSubject.toCompletable();
-        
+
         Subscription completableSubscription = completable.subscribe(Actions.empty(), Actions.empty());
-        
+
         stringSubject.onError(new TestException());
-        
+
         assertTrue("Not unsubscribed?", completableSubscription.isUnsubscribed());
     }
 
@@ -3838,7 +3838,7 @@ public void subscribeAction2ReportsUnsubscribedOnError() {
     public void subscribeAction2ReportsUnsubscribedAfter() {
         PublishSubject<String> stringSubject = PublishSubject.create();
         Completable completable = stringSubject.toCompletable();
-        
+
         final AtomicReference<Subscription> subscriptionRef = new AtomicReference<Subscription>();
         Subscription completableSubscription = completable.subscribe(new Action0() {
             @Override
@@ -3849,9 +3849,9 @@ public void call() {
             }
         }, Actions.empty());
         subscriptionRef.set(completableSubscription);
-        
+
         stringSubject.onCompleted();
-        
+
         assertTrue("Not unsubscribed?", completableSubscription.isUnsubscribed());
         assertNotNull("Unsubscribed before the call to onCompleted", subscriptionRef.get());
     }
@@ -3860,7 +3860,7 @@ public void call() {
     public void subscribeAction2ReportsUnsubscribedOnErrorAfter() {
         PublishSubject<String> stringSubject = PublishSubject.create();
         Completable completable = stringSubject.toCompletable();
-        
+
         final AtomicReference<Subscription> subscriptionRef = new AtomicReference<Subscription>();
         Subscription completableSubscription = completable.subscribe(Actions.empty(), new Action1<Throwable>() {
             @Override
@@ -3871,9 +3871,9 @@ public void call(Throwable e) {
             }
         });
         subscriptionRef.set(completableSubscription);
-        
+
         stringSubject.onError(new TestException());
-        
+
         assertTrue("Not unsubscribed?", completableSubscription.isUnsubscribed());
         assertNotNull("Unsubscribed before the call to onError", subscriptionRef.get());
     }
@@ -3902,28 +3902,28 @@ private static void expectUncaughtTestException(Action0 action) {
     public void safeOnCompleteThrows() {
         try {
             normal.completable.subscribe(new CompletableSubscriber() {
-    
+
                 @Override
                 public void onCompleted() {
                     throw new TestException("Forced failure");
                 }
-    
+
                 @Override
                 public void onError(Throwable e) {
-                    
+
                 }
-    
+
                 @Override
                 public void onSubscribe(Subscription d) {
-                    
+
                 }
-                
+
             });
             Assert.fail("Did not propagate exception!");
         } catch (OnCompletedFailedException ex) {
             Throwable c = ex.getCause();
             Assert.assertNotNull(c);
-            
+
             Assert.assertEquals("Forced failure", c.getMessage());
         }
     }
@@ -3932,27 +3932,27 @@ public void onSubscribe(Subscription d) {
     public void safeOnCompleteThrowsRegularSubscriber() {
         try {
             normal.completable.subscribe(new Subscriber<Object>() {
-    
+
                 @Override
                 public void onCompleted() {
                     throw new TestException("Forced failure");
                 }
-    
+
                 @Override
                 public void onError(Throwable e) {
-                    
+
                 }
-    
+
                 @Override
                 public void onNext(Object t) {
-                    
+
                 }
             });
             Assert.fail("Did not propagate exception!");
         } catch (OnCompletedFailedException ex) {
             Throwable c = ex.getCause();
             Assert.assertNotNull(c);
-            
+
             Assert.assertEquals("Forced failure", c.getMessage());
         }
     }
@@ -3961,31 +3961,31 @@ public void onNext(Object t) {
     public void safeOnErrorThrows() {
         try {
             error.completable.subscribe(new CompletableSubscriber() {
-    
+
                 @Override
                 public void onCompleted() {
                 }
-    
+
                 @Override
                 public void onError(Throwable e) {
                     throw new TestException("Forced failure");
                 }
-    
+
                 @Override
                 public void onSubscribe(Subscription d) {
-                    
+
                 }
-                
+
             });
             Assert.fail("Did not propagate exception!");
         } catch (OnErrorFailedException ex) {
             Throwable c = ex.getCause();
             Assert.assertTrue("" + c, c instanceof CompositeException);
-            
+
             CompositeException ce = (CompositeException)c;
-            
+
             List<Throwable> list = ce.getExceptions();
-            
+
             Assert.assertEquals(2, list.size());
 
             Assert.assertTrue("" + list.get(0), list.get(0) instanceof TestException);
@@ -4000,31 +4000,31 @@ public void onSubscribe(Subscription d) {
     public void safeOnErrorThrowsRegularSubscriber() {
         try {
             error.completable.subscribe(new Subscriber<Object>() {
-    
+
                 @Override
                 public void onCompleted() {
 
                 }
-    
+
                 @Override
                 public void onError(Throwable e) {
                     throw new TestException("Forced failure");
                 }
-    
+
                 @Override
                 public void onNext(Object t) {
-                    
+
                 }
             });
             Assert.fail("Did not propagate exception!");
         } catch (OnErrorFailedException ex) {
             Throwable c = ex.getCause();
             Assert.assertTrue("" + c, c instanceof CompositeException);
-            
+
             CompositeException ce = (CompositeException)c;
-            
+
             List<Throwable> list = ce.getExceptions();
-            
+
             Assert.assertEquals(2, list.size());
 
             Assert.assertTrue("" + list.get(0), list.get(0) instanceof TestException);
@@ -4036,7 +4036,7 @@ public void onNext(Object t) {
     }
 
     private Func1<OnSubscribe, OnSubscribe> onCreate;
-    
+
     private Func2<Completable, OnSubscribe, OnSubscribe> onStart;
 
     @Before
@@ -4047,19 +4047,19 @@ public OnSubscribe call(OnSubscribe t) {
                 return t;
             }
         });
-        
+
         RxJavaHooks.setOnCompletableCreate(onCreate);
-        
+
         onStart = spy(new Func2<Completable, OnSubscribe, OnSubscribe>() {
             @Override
             public OnSubscribe call(Completable t1, OnSubscribe t2) {
                 return t2;
             }
         });
-        
+
         RxJavaHooks.setOnCompletableStart(onStart);
     }
-    
+
     @After
     public void after() {
         RxJavaHooks.reset();
@@ -4108,9 +4108,9 @@ public void onStart() {
                 onNext(1);
             }
         };
-        
+
         normal.completable.subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -4124,9 +4124,9 @@ public void onStart() {
                 onNext(1);
             }
         };
-        
+
         normal.completable.unsafeSubscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -4135,7 +4135,7 @@ public void onStart() {
     @Test
     public void onErrorCompleteFunctionThrows() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
-        
+
         error.completable.onErrorComplete(new Func1<Throwable, Boolean>() {
             @Override
             public Boolean call(Throwable t) {
@@ -4146,12 +4146,12 @@ public Boolean call(Throwable t) {
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(CompositeException.class);
-        
+
         CompositeException composite = (CompositeException)ts.getOnErrorEvents().get(0);
-        
+
         List<Throwable> errors = composite.getExceptions();
         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.assertTrue(errors.get(1).toString(), errors.get(1) instanceof TestException);
diff --git a/src/test/java/rx/ConcatTests.java b/src/test/java/rx/ConcatTests.java
index e357ea5030..558f8af1dd 100644
--- a/src/test/java/rx/ConcatTests.java
+++ b/src/test/java/rx/ConcatTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -76,7 +76,7 @@ public void testConcatWithIterableOfObservable() {
         assertEquals("three", values.get(2));
         assertEquals("four", values.get(3));
         assertEquals("five", values.get(4));
-        assertEquals("six", values.get(5));        
+        assertEquals("six", values.get(5));
     }
 
     @Test
@@ -85,14 +85,14 @@ public void testConcatCovariance() {
         Movie movie = new Movie();
         Media media = new Media();
         HorrorMovie horrorMovie2 = new HorrorMovie();
-        
+
         Observable<Media> o1 = Observable.<Media> just(horrorMovie1, movie);
         Observable<Media> o2 = Observable.just(media, horrorMovie2);
 
         Observable<Observable<Media>> os = Observable.just(o1, o2);
 
         List<Media> values = Observable.concat(os).toList().toBlocking().single();
-        
+
         assertEquals(horrorMovie1, values.get(0));
         assertEquals(movie, values.get(1));
         assertEquals(media, values.get(2));
@@ -107,7 +107,7 @@ public void testConcatCovariance2() {
         Media media1 = new Media();
         Media media2 = new Media();
         HorrorMovie horrorMovie2 = new HorrorMovie();
-        
+
         Observable<Media> o1 = Observable.just(horrorMovie1, movie, media1);
         Observable<Media> o2 = Observable.just(media2, horrorMovie2);
 
@@ -129,7 +129,7 @@ public void testConcatCovariance3() {
         Movie movie = new Movie();
         Media media = new Media();
         HorrorMovie horrorMovie2 = new HorrorMovie();
-        
+
         Observable<Movie> o1 = Observable.just(horrorMovie1, movie);
         Observable<Media> o2 = Observable.just(media, horrorMovie2);
 
@@ -148,7 +148,7 @@ public void testConcatCovariance4() {
         final Movie movie = new Movie();
         Media media = new Media();
         HorrorMovie horrorMovie2 = new HorrorMovie();
-        
+
         Observable<Movie> o1 = Observable.create(new OnSubscribe<Movie>() {
 
             @Override
diff --git a/src/test/java/rx/CovarianceTest.java b/src/test/java/rx/CovarianceTest.java
index cca05ae36c..3d19821967 100644
--- a/src/test/java/rx/CovarianceTest.java
+++ b/src/test/java/rx/CovarianceTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -33,7 +33,7 @@
 
 /**
  * Test super/extends of generics.
- * 
+ *
  * See https://github.com/Netflix/RxJava/pull/331
  */
 public class CovarianceTest {
@@ -116,10 +116,10 @@ public void testCovarianceOfCompose() {
             public Observable<Movie> call(Observable<Movie> t1) {
                 return Observable.just(new Movie());
             }
-            
+
         });
     }
-    
+
     @SuppressWarnings("unused")
     @Test
     public void testCovarianceOfCompose2() {
@@ -167,7 +167,7 @@ public HorrorMovie call(HorrorMovie horrorMovie) {
             }
         });
     }
-    
+
     @Test
     public void testComposeWithDeltaLogic() {
         List<Movie> list1 = Arrays.asList(new Movie(), new HorrorMovie(), new ActionMovie());
diff --git a/src/test/java/rx/ErrorHandlingTests.java b/src/test/java/rx/ErrorHandlingTests.java
index 2da7aea120..3f52dad66b 100644
--- a/src/test/java/rx/ErrorHandlingTests.java
+++ b/src/test/java/rx/ErrorHandlingTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/EventStream.java b/src/test/java/rx/EventStream.java
index dc8d1e03d7..632e649601 100644
--- a/src/test/java/rx/EventStream.java
+++ b/src/test/java/rx/EventStream.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/GroupByTests.java b/src/test/java/rx/GroupByTests.java
index a4527777ef..03a2ee75e9 100644
--- a/src/test/java/rx/GroupByTests.java
+++ b/src/test/java/rx/GroupByTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -91,11 +91,11 @@ public void call(String v) {
 
         System.out.println("**** finished");
     }
-    
+
     @Test
     public void groupsCompleteAsSoonAsMainCompletes() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(0, 20)
         .groupBy(new Func1<Integer, Integer>() {
             @Override
@@ -109,7 +109,7 @@ public Observable<Integer> call(GroupedObservable<Integer, Integer> v) {
                 return v;
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(0, 5, 10, 15, 1, 6, 11, 16, 2, 7, 12, 17, 3, 8, 13, 18, 4, 9, 14, 19);
         ts.assertCompleted();
         ts.assertNoErrors();
diff --git a/src/test/java/rx/IntervalDemo.java b/src/test/java/rx/IntervalDemo.java
index e95105e9d5..a0fb028e10 100644
--- a/src/test/java/rx/IntervalDemo.java
+++ b/src/test/java/rx/IntervalDemo.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/MergeTests.java b/src/test/java/rx/MergeTests.java
index 51f99caaa7..07bba783ea 100644
--- a/src/test/java/rx/MergeTests.java
+++ b/src/test/java/rx/MergeTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -48,7 +48,7 @@ public void testMergeCovariance() {
         Observable<Observable<Media>> os = Observable.just(o1, o2);
 
         List<Media> values = Observable.merge(os).toList().toBlocking().single();
-        
+
         assertEquals(4, values.size());
     }
 
diff --git a/src/test/java/rx/NotificationTest.java b/src/test/java/rx/NotificationTest.java
index 34aa36de8e..df79092ff4 100644
--- a/src/test/java/rx/NotificationTest.java
+++ b/src/test/java/rx/NotificationTest.java
@@ -157,7 +157,7 @@ public void equalsWorks() {
         Notification<Integer> z1 = Notification.createOnNext(null);
         Notification<Integer> z1a = Notification.createOnNext(null);
 
-        
+
         Notification<Integer> n1 = Notification.createOnNext(1);
         Notification<Integer> n1a = Notification.createOnNext(new Integer(1)); // make unique reference
         Notification<Integer> n2 = Notification.createOnNext(2);
@@ -184,11 +184,11 @@ public void equalsWorks() {
 
         assertFalse(n1.equals(null));
         assertFalse(n1.equals(1));
-        
+
         assertEquals(z1a, z1);
         assertEquals(z1, z1a);
     }
-    
+
     @Test
     public void contentChecks() {
         Notification<Integer> z1 = Notification.createOnNext(null);
@@ -200,11 +200,11 @@ public void contentChecks() {
         assertFalse(z1.hasValue());
         assertFalse(z1.hasThrowable());
         assertFalse(z1.isOnCompleted());
-        
+
         assertTrue(n1.hasValue());
         assertFalse(n1.hasThrowable());
         assertFalse(n1.isOnCompleted());
-        
+
         assertFalse(e1.hasValue());
         assertTrue(e1.hasThrowable());
         assertFalse(e1.isOnCompleted());
@@ -218,13 +218,13 @@ public void contentChecks() {
         assertTrue(c1.isOnCompleted());
 
     }
-    
+
     @Test
     public void exceptionEquality() {
         EqualException ex1 = new EqualException("1");
         EqualException ex2 = new EqualException("1");
         EqualException ex3 = new EqualException("3");
-        
+
         Notification<Integer> e1 = Notification.createOnError(ex1);
         Notification<Integer> e2 = Notification.createOnError(ex2);
         Notification<Integer> e3 = Notification.createOnError(ex3);
@@ -233,22 +233,22 @@ public void exceptionEquality() {
         assertEquals(e1, e2);
         assertEquals(e2, e1);
         assertEquals(e2, e2);
-        
+
         assertNotEquals(e1, e3);
         assertNotEquals(e2, e3);
         assertNotEquals(e3, e1);
         assertNotEquals(e3, e2);
     }
-    
+
     static final class EqualException extends RuntimeException {
-        
+
         /** */
         private static final long serialVersionUID = 446310455393317050L;
 
         public EqualException(String message) {
             super(message);
         }
-        
+
         @Override
         public boolean equals(Object o) {
             if (o instanceof EqualException) {
diff --git a/src/test/java/rx/ObservableConversionTest.java b/src/test/java/rx/ObservableConversionTest.java
index 6e0e0e1c23..0c5041bbb9 100644
--- a/src/test/java/rx/ObservableConversionTest.java
+++ b/src/test/java/rx/ObservableConversionTest.java
@@ -38,20 +38,20 @@
 
 @SuppressWarnings("deprecation")
 public class ObservableConversionTest {
-    
+
     public static class Cylon {}
-    
+
     public static class Jail {
         Object cylon;
-        
+
         Jail(Object cylon) {
             this.cylon = cylon;
         }
     }
-    
+
     public static class CylonDetectorObservable<T> {
         protected OnSubscribe<T> onSubscribe;
-        
+
         public static <T> CylonDetectorObservable<T> create(OnSubscribe<T> onSubscribe) {
             return new CylonDetectorObservable<T>(onSubscribe);
         }
@@ -67,7 +67,7 @@ public void subscribe(Subscriber<T> subscriber) {
         public <R> CylonDetectorObservable<R> lift(Operator<? extends R, ? super T> operator) {
             return x(new RobotConversionFunc<T, R>(operator));
         }
-        
+
         public <R, O> O x(Func1<OnSubscribe<T>, O> operator) {
             return operator.call(onSubscribe);
         }
@@ -75,11 +75,11 @@ public <R, O> O x(Func1<OnSubscribe<T>, O> operator) {
         public <R> CylonDetectorObservable<? extends R> compose(Func1<CylonDetectorObservable<? super T>, CylonDetectorObservable<? extends R>> transformer) {
             return transformer.call(this);
         }
-        
+
         public final CylonDetectorObservable<T> beep(Func1<? super T, Boolean> predicate) {
             return create(new OnSubscribeFilter<T>(Observable.create(onSubscribe), predicate));
         }
-        
+
         public final <R> CylonDetectorObservable<R> boop(Func1<? super T, ? extends R> func) {
             return create(new OnSubscribeMap<T, R>(Observable.create(onSubscribe), func));
         }
@@ -99,12 +99,12 @@ public String call(T t) {
                     }
                 }});
         }
-        
+
         private static void throwOutTheAirlock(Object cylon) {
             // ...
         }
     }
-    
+
     public static class RobotConversionFunc<T, R> implements Func1<OnSubscribe<T>, CylonDetectorObservable<R>> {
         private Operator<? extends R, ? super T> operator;
 
@@ -132,25 +132,25 @@ public void call(Subscriber<? super R> o) {
                     } catch (Throwable e) {
                         o.onError(e);
                     }
-                
+
                 }});
         }
     }
-    
+
     public static class ConvertToCylonDetector<T> implements Func1<OnSubscribe<T>, CylonDetectorObservable<T>> {
         @Override
         public CylonDetectorObservable<T> call(final OnSubscribe<T> onSubscribe) {
             return CylonDetectorObservable.create(onSubscribe);
         }
     }
-    
+
     public static class ConvertToObservable<T> implements Func1<OnSubscribe<T>, Observable<T>> {
         @Override
         public Observable<T> call(final OnSubscribe<T> onSubscribe) {
             return Observable.create(onSubscribe);
         }
     }
-    
+
     @Test
     public void testConversionBetweenObservableClasses() {
         final TestSubscriber<String> subscriber = new TestSubscriber<String>(new Subscriber<String>(){
@@ -194,7 +194,7 @@ public String call(String a, String n) {
         subscriber.assertNoErrors();
         subscriber.assertCompleted();
     }
-    
+
     @Test
     public void testConvertToConcurrentQueue() {
         final AtomicReference<Throwable> thrown = new AtomicReference<Throwable>(null);
@@ -225,19 +225,19 @@ public ConcurrentLinkedQueue<Integer> call(OnSubscribe<Integer> onSubscribe) {
                                 public void onCompleted() {
                                     isFinished.set(true);
                                 }
-        
+
                                 @Override
                                 public void onError(Throwable e) {
                                     thrown.set(e);
                                 }
-        
+
                                 @Override
                                 public void onNext(Integer t) {
                                     q.add(t);
                                 }});
                             return q;
                         }});
-        
+
         int x = 0;
         while(!isFinished.get()) {
             Integer i = queue.poll();
diff --git a/src/test/java/rx/ObservableDoOnTest.java b/src/test/java/rx/ObservableDoOnTest.java
index 0f22e6ecbd..ffd73ea450 100644
--- a/src/test/java/rx/ObservableDoOnTest.java
+++ b/src/test/java/rx/ObservableDoOnTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
index 115fe34735..3614af3af7 100644
--- a/src/test/java/rx/ObservableTests.java
+++ b/src/test/java/rx/ObservableTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -250,7 +250,7 @@ public void call(Integer t1) {
 
     /**
      * A reduce on an empty Observable and a seed should just pass the seed through.
-     * 
+     *
      * This is confirmed at https://github.com/ReactiveX/RxJava/issues/423#issuecomment-27642456
      */
     @Test
@@ -319,9 +319,9 @@ public void testMaterializeDematerializeChaining() {
 
     /**
      * The error from the user provided Observer is not handled by the subscribe method try/catch.
-     * 
+     *
      * It is handled by the AtomicObserver that wraps the provided Observer.
-     * 
+     *
      * Result: Passes (if AtomicObserver functionality exists)
      * @throws InterruptedException on interrupt
      */
@@ -388,7 +388,7 @@ public void onNext(String v) {
 
     /**
      * The error from the user provided Observer is handled by the subscribe try/catch because this is synchronous
-     * 
+     *
      * Result: Passes
      */
     @Test
@@ -437,8 +437,8 @@ public void onNext(String v) {
 
     /**
      * The error from the user provided Observable is handled by the subscribe try/catch because this is synchronous
-     * 
-     * 
+     *
+     *
      * Result: Passes
      */
     @Test
@@ -672,9 +672,9 @@ public void call(String v) {
 
     /**
      * https://github.com/ReactiveX/RxJava/issues/198
-     * 
+     *
      * Rx Design Guidelines 5.2
-     * 
+     *
      * "when calling the Subscribe method that only has an onNext argument, the OnError behavior will be
      * to rethrow the exception on the thread that the message comes out from the Observable.
      * The OnCompleted behavior in this case is to do nothing."
@@ -698,13 +698,13 @@ public void call(Object t1) {
 
     /**
      * https://github.com/ReactiveX/RxJava/issues/198
-     * 
+     *
      * Rx Design Guidelines 5.2
-     * 
+     *
      * "when calling the Subscribe method that only has an onNext argument, the OnError behavior will be
      * to rethrow the exception on the thread that the message comes out from the Observable.
      * The OnCompleted behavior in this case is to do nothing."
-     * 
+     *
      * @throws InterruptedException
      */
     @Test
@@ -886,13 +886,13 @@ public void testIgnoreElements() {
             public void testJustWithScheduler() {
                 TestScheduler scheduler = new TestScheduler();
                 Observable<Integer> observable = Observable.from(Arrays.asList(1, 2)).subscribeOn(scheduler);
-        
+
                 @SuppressWarnings("unchecked")
                 Observer<Integer> observer = mock(Observer.class);
                 observable.subscribe(observer);
-        
+
                 scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
-        
+
                 InOrder inOrder = inOrder(observer);
                 inOrder.verify(observer, times(1)).onNext(1);
                 inOrder.verify(observer, times(1)).onNext(2);
@@ -940,21 +940,21 @@ public void testRangeWithScheduler() {
         inOrder.verifyNoMoreInteractions();
     }
 
-        
+
     @Test
     public void testMergeWith() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         Observable.just(1).mergeWith(Observable.just(2)).subscribe(ts);
         ts.assertReceivedOnNext(Arrays.asList(1, 2));
     }
-    
+
     @Test
     public void testConcatWith() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         Observable.just(1).concatWith(Observable.just(2)).subscribe(ts);
         ts.assertReceivedOnNext(Arrays.asList(1, 2));
     }
-    
+
     @Test
     public void testAmbWith() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -997,7 +997,7 @@ public void call(List<Boolean> booleans) {
         }
         assertEquals(expectedCount, count.get());
     }
-    
+
     @Test
     public void testCompose() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
@@ -1006,31 +1006,31 @@ public void testCompose() {
             @Override
             public Observable<String> call(Observable<Integer> t1) {
                 return t1.map(new Func1<Integer, String>() {
-                    
+
                     @Override
                     public String call(Integer t1) {
                         return String.valueOf(t1);
                     }
-                    
+
                 });
             }
-            
+
         }).subscribe(ts);
         ts.assertTerminalEvent();
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList("1", "2", "3"));
     }
-    
+
     @Test
     public void testErrorThrownIssue1685() throws Exception {
         Subject<Object, Object> subject = ReplaySubject.create();
 
         ExecutorService exec = Executors.newSingleThreadExecutor();
-        
+
         try {
-            
+
             final AtomicReference<Throwable> err = new AtomicReference<Throwable>();
-            
+
             Scheduler s = Schedulers.from(exec);
             exec.submit(new Runnable() {
                 @Override
@@ -1043,7 +1043,7 @@ public void uncaughtException(Thread t, Throwable e) {
                     });
                 }
             }).get();
-            
+
             subject.subscribe();
 
             Observable.error(new RuntimeException("oops"))
@@ -1051,15 +1051,15 @@ public void uncaughtException(Thread t, Throwable e) {
                 .delay(1, TimeUnit.SECONDS, s)
                 .dematerialize()
                 .subscribe(subject);
-    
+
             subject.materialize().toBlocking().first();
 
             for (int i = 0; i < 50 && err.get() == null; i++) {
                 Thread.sleep(100); // the uncaught exception comes after the terminal event reaches toBlocking
             }
-            
+
             assertNotNull("UncaughtExceptionHandler didn't get anything.", err.get());
-            
+
             System.out.println("Done");
         } finally {
             exec.shutdownNow();
@@ -1070,16 +1070,16 @@ public void uncaughtException(Thread t, Throwable e) {
     public void testEmptyIdentity() {
         assertEquals(Observable.empty(), Observable.empty());
     }
-    
+
     @Test
     public void testEmptyIsEmpty() {
         Observable.<Integer>empty().subscribe(w);
-        
+
         verify(w).onCompleted();
         verify(w, never()).onNext(any(Integer.class));
         verify(w, never()).onError(any(Throwable.class));
     }
-    
+
     @Test // cf. https://github.com/ReactiveX/RxJava/issues/2599
     public void testSubscribingSubscriberAsObserverMaintainsSubscriptionChain() {
         TestSubscriber<Object> subscriber = new TestSubscriber<Object>();
@@ -1099,14 +1099,14 @@ public void call(Object t) {
                 //do nothing
             }});
     }
-    
+
     @Test(expected=IllegalArgumentException.class)
     public void testForEachWithNull() {
         Observable.error(new Exception("boo"))
         //
         .forEach(null);
     }
-    
+
     @SuppressWarnings("deprecation")
     @Test
     public void testExtend() {
@@ -1122,11 +1122,11 @@ public Object call(OnSubscribe<Object> onSubscribe) {
                 return subscriber.getOnNextEvents().get(0);
             }});
     }
-    
+
     @Test
     public void nullOnSubscribe() {
         Observable<Integer> source = Observable.create((OnSubscribe<Integer>)null);
-        
+
         try {
             source.subscribe();
             fail("Should have thrown IllegalStateException");
@@ -1134,11 +1134,11 @@ public void nullOnSubscribe() {
             // expected
         }
     }
-    
+
     @Test
     public void nullObserver() {
         Observable<Integer> source = Observable.just(1);
-        
+
         try {
             source.subscribe((Observer<Integer>)null);
             fail("Should have thrown IllegalStateException");
@@ -1150,7 +1150,7 @@ public void nullObserver() {
     @Test
     public void nullSubscriber() {
         Observable<Integer> source = Observable.just(1);
-        
+
         try {
             source.subscribe((Subscriber<Integer>)null);
             fail("Should have thrown IllegalStateException");
@@ -1205,7 +1205,7 @@ public void call(String v) {
         assertTrue("subscriptions did not receive values", latch.await(1000, TimeUnit.MILLISECONDS));
         assertEquals(1, counter.get());
     }
-    
+
     @Test
     public void subscribeWithNull() {
         Action1<Integer> onNext = Actions.empty();
@@ -1231,7 +1231,7 @@ public void subscribeWithNull() {
         } catch (IllegalArgumentException ex) {
             assertEquals("onNext can not be null", ex.getMessage());
         }
-        
+
         try {
             Observable.just(1).subscribe(onNext, null);
             fail("Should have thrown IllegalArgumentException");
@@ -1245,7 +1245,7 @@ public void subscribeWithNull() {
         } catch (IllegalArgumentException ex) {
             assertEquals("onError can not be null", ex.getMessage());
         }
-        
+
         try {
             Observable.just(1).subscribe(onNext, onError, null);
             fail("Should have thrown IllegalArgumentException");
@@ -1253,7 +1253,7 @@ public void subscribeWithNull() {
             assertEquals("onComplete can not be null", ex.getMessage());
         }
     }
-    
+
     @Test
     public void forEachWithNull() {
         Action1<Integer> onNext = Actions.empty();
@@ -1279,7 +1279,7 @@ public void forEachWithNull() {
         } catch (IllegalArgumentException ex) {
             assertEquals("onNext can not be null", ex.getMessage());
         }
-        
+
         try {
             Observable.just(1).forEach(onNext, null);
             fail("Should have thrown IllegalArgumentException");
@@ -1293,7 +1293,7 @@ public void forEachWithNull() {
         } catch (IllegalArgumentException ex) {
             assertEquals("onError can not be null", ex.getMessage());
         }
-        
+
         try {
             Observable.just(1).forEach(onNext, onError, null);
             fail("Should have thrown IllegalArgumentException");
@@ -1301,32 +1301,32 @@ public void forEachWithNull() {
             assertEquals("onComplete can not be null", ex.getMessage());
         }
     }
-    
+
     @Test
     public void observableThrowsWhileSubscriberIsUnsubscribed() {
         TestSubscriber<Object> ts = TestSubscriber.create();
         ts.unsubscribe();
-        
+
         final List<Throwable> list = new ArrayList<Throwable>();
-        
+
         RxJavaHooks.setOnError(new Action1<Throwable>() {
             @Override
             public void call(Throwable t) {
                 list.add(t);
             }
         });
-        
+
         try {
             new FailingObservable().subscribe(ts);
-            
+
             assertEquals(1, list.size());
-            
+
             assertEquals("Forced failure", list.get(0).getMessage());
         } finally {
             RxJavaHooks.reset();
         }
     }
-    
+
     @Test
     public void observableThrowsWhileOnErrorFails() {
         Subscriber<Object> ts = new SafeSubscriber<Object>(new TestSubscriber<Object>()) {
@@ -1335,7 +1335,7 @@ public void onError(Throwable e) {
                 throw new TestException("Forced failure");
             }
         };
-        
+
         try {
             new FailingObservable().subscribe(ts);
             fail("Should have thrown OnErrorFailedException");
@@ -1345,7 +1345,7 @@ public void onError(Throwable e) {
             assertEquals("Forced failure", ex.getCause().getMessage());
         }
     }
-    
+
     @Test
     public void observableThrowsWhileOnErrorFailsUnsafe() {
         Subscriber<Object> ts = new TestSubscriber<Object>() {
@@ -1354,7 +1354,7 @@ public void onError(Throwable e) {
                 throw new TestException("Forced failure");
             }
         };
-        
+
         try {
             new FailingObservable().unsafeSubscribe(ts);
             fail("Should have thrown OnErrorFailedException");
@@ -1364,7 +1364,7 @@ public void onError(Throwable e) {
             assertEquals("Forced failure", ex.getCause().getMessage());
         }
     }
-    
+
     static final class FailingObservable extends Observable<Object> {
 
         protected FailingObservable() {
@@ -1375,9 +1375,9 @@ public void call(Subscriber<? super Object> t) {
                 }
             });
         }
-        
+
     }
-    
+
     @Test
     public void forEachWithError() {
         Action1<Throwable> onError = Actions.empty();
@@ -1389,7 +1389,7 @@ public void call(Integer t) {
                 list.add(t);
             }
         }, onError);
-        
+
         Observable.<Integer>error(new TestException()).forEach(new Action1<Integer>() {
             @Override
             public void call(Integer t) {
@@ -1401,7 +1401,7 @@ public void call(Throwable t) {
                 list.add(t);
             }
         });
-        
+
         Observable.<Integer>empty().forEach(new Action1<Integer>() {
             @Override
             public void call(Integer t) {
diff --git a/src/test/java/rx/ObservableWindowTests.java b/src/test/java/rx/ObservableWindowTests.java
index 3833b934a9..a512186416 100644
--- a/src/test/java/rx/ObservableWindowTests.java
+++ b/src/test/java/rx/ObservableWindowTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/ReduceTests.java b/src/test/java/rx/ReduceTests.java
index f7445e4aea..0e0e4735d0 100644
--- a/src/test/java/rx/ReduceTests.java
+++ b/src/test/java/rx/ReduceTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -59,7 +59,7 @@ public Movie call(Movie t1, Movie t2) {
 
     /**
      * Reduce consumes and produces T so can't do covariance.
-     * 
+     *
      * https://github.com/ReactiveX/RxJava/issues/360#issuecomment-24203016
      */
     @SuppressWarnings("unused")
@@ -80,7 +80,7 @@ public Movie call(Movie t1, Movie t2) {
 
     /**
      * Reduce consumes and produces T so can't do covariance.
-     * 
+     *
      * https://github.com/ReactiveX/RxJava/issues/360#issuecomment-24203016
      */
     @Test
diff --git a/src/test/java/rx/ScanTests.java b/src/test/java/rx/ScanTests.java
index 36cb429255..06e557b50d 100644
--- a/src/test/java/rx/ScanTests.java
+++ b/src/test/java/rx/ScanTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/SchedulerWorkerTest.java b/src/test/java/rx/SchedulerWorkerTest.java
index 8bb1094b46..16d0c65553 100644
--- a/src/test/java/rx/SchedulerWorkerTest.java
+++ b/src/test/java/rx/SchedulerWorkerTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -26,7 +26,7 @@
 import rx.schedulers.Schedulers;
 
 public class SchedulerWorkerTest {
-    
+
     static final class CustomDriftScheduler extends Scheduler {
         public volatile long drift;
         @Override
@@ -53,29 +53,29 @@ public Subscription schedule(Action0 action) {
                 public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
                     return w.schedule(action, delayTime, unit);
                 }
-                
+
                 @Override
                 public long now() {
                     return super.now() + drift;
                 }
             };
         }
-        
+
         @Override
         public long now() {
             return super.now() + drift;
         }
     }
-    
+
     @Test
     public void testCurrentTimeDriftBackwards() throws Exception {
         CustomDriftScheduler s = new CustomDriftScheduler();
-        
+
         Scheduler.Worker w = s.createWorker();
-        
+
         try {
             final List<Long> times = new ArrayList<Long>();
-            
+
             Subscription d = w.schedulePeriodically(new Action0() {
                 @Override
                 public void call() {
@@ -84,17 +84,17 @@ public void call() {
             }, 100, 100, TimeUnit.MILLISECONDS);
 
             Thread.sleep(150);
-            
+
             s.drift = -1000 - TimeUnit.NANOSECONDS.toMillis(Scheduler.CLOCK_DRIFT_TOLERANCE_NANOS);
-            
+
             Thread.sleep(400);
-            
+
             d.unsubscribe();
-            
+
             Thread.sleep(150);
-            
+
             System.out.println("Runs: " + times.size());
-            
+
             for (int i = 0; i < times.size() - 1 ; i++) {
                 long diff = times.get(i + 1) - times.get(i);
                 System.out.println("Diff #" + i + ": " + diff);
@@ -102,22 +102,22 @@ public void call() {
             }
 
             assertTrue("Too few invocations: " + times.size(), times.size() > 2);
-            
+
         } finally {
             w.unsubscribe();
         }
-        
+
     }
-    
+
     @Test
     public void testCurrentTimeDriftForwards() throws Exception {
         CustomDriftScheduler s = new CustomDriftScheduler();
-        
+
         Scheduler.Worker w = s.createWorker();
-        
+
         try {
             final List<Long> times = new ArrayList<Long>();
-            
+
             Subscription d = w.schedulePeriodically(new Action0() {
                 @Override
                 public void call() {
@@ -126,28 +126,28 @@ public void call() {
             }, 100, 100, TimeUnit.MILLISECONDS);
 
             Thread.sleep(150);
-            
+
             s.drift = 1000 + TimeUnit.NANOSECONDS.toMillis(Scheduler.CLOCK_DRIFT_TOLERANCE_NANOS);
-            
+
             Thread.sleep(400);
-            
+
             d.unsubscribe();
-            
+
             Thread.sleep(150);
-            
+
             System.out.println("Runs: " + times.size());
-            
+
             assertTrue(times.size() > 2);
-            
+
             for (int i = 0; i < times.size() - 1 ; i++) {
                 long diff = times.get(i + 1) - times.get(i);
                 System.out.println("Diff #" + i + ": " + diff);
                 assertTrue("Diff out of range: " + diff, diff < 250 && diff > 50);
             }
-            
+
         } finally {
             w.unsubscribe();
         }
-        
+
     }
 }
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index d4bd0748b3..bf05ddd937 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -39,7 +39,7 @@ public class SingleTest {
 
     @SuppressWarnings("rawtypes")
     private Func1<Single.OnSubscribe, Single.OnSubscribe> onCreate;
-    
+
     @SuppressWarnings("rawtypes")
     private Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> onStart;
 
@@ -54,28 +54,28 @@ public Single.OnSubscribe call(Single.OnSubscribe t) {
                 return t;
             }
         });
-        
+
         RxJavaHooks.setOnSingleCreate(onCreate);
-        
+
         onStart = spy(new Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe>() {
             @Override
             public Observable.OnSubscribe call(Single t1, Observable.OnSubscribe t2) {
                 return t2;
             }
         });
-        
+
         RxJavaHooks.setOnSingleStart(onStart);
-        
+
         onReturn = spy(new Func1<Subscription, Subscription>() {
             @Override
             public Subscription call(Subscription t) {
                 return t;
             }
         });
-        
+
         RxJavaHooks.setOnSingleReturn(onReturn);
     }
-    
+
     @After
     public void after() {
         RxJavaHooks.reset();
@@ -1979,7 +1979,7 @@ public void subscribeWithNullObserver() {
     @Test
     public void unsubscribeComposesThrough() {
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         Subscription s = ps.toSingle()
         .flatMap(new Func1<Integer, Single<Integer>>() {
             @Override
@@ -1988,16 +1988,16 @@ public Single<Integer> call(Integer v) {
             }
         })
         .subscribe();
-        
+
         s.unsubscribe();
-        
+
         assertFalse("Observers present?!", ps.hasObservers());
     }
 
     @Test(timeout = 1000)
     public void unsubscribeComposesThroughAsync() {
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         Subscription s = ps.toSingle()
         .subscribeOn(Schedulers.io())
         .flatMap(new Func1<Integer, Single<Integer>>() {
@@ -2007,11 +2007,11 @@ public Single<Integer> call(Integer v) {
             }
         })
         .subscribe();
-        
+
         while (!ps.hasObservers() && !Thread.currentThread().isInterrupted()) ;
-        
+
         s.unsubscribe();
-        
+
         assertFalse("Observers present?!", ps.hasObservers());
     }
 
diff --git a/src/test/java/rx/StartWithTests.java b/src/test/java/rx/StartWithTests.java
index 4153ea325b..bf628384d6 100644
--- a/src/test/java/rx/StartWithTests.java
+++ b/src/test/java/rx/StartWithTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/SubscriberTest.java b/src/test/java/rx/SubscriberTest.java
index 95d489e2c6..82abd5fee6 100644
--- a/src/test/java/rx/SubscriberTest.java
+++ b/src/test/java/rx/SubscriberTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -423,7 +423,7 @@ public void onNext(Integer t) {
 
         assertEquals(1, c.get());
     }
-    
+
     @Test
     public void testNegativeRequestThrowsIllegalArgumentException() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
@@ -434,10 +434,10 @@ public void testNegativeRequestThrowsIllegalArgumentException() throws Interrupt
             public void onStart() {
                 request(1);
             }
-            
+
             @Override
             public void onCompleted() {
-                
+
             }
 
             @Override
@@ -454,7 +454,7 @@ public void onNext(Integer t) {
         assertTrue(latch.await(10, TimeUnit.SECONDS));
         assertTrue(exception.get() instanceof IllegalArgumentException);
     }
-    
+
     @Test
     public void testOnStartRequestsAreAdditive() {
         final List<Integer> list = new ArrayList<Integer>();
@@ -464,15 +464,15 @@ public void onStart() {
                 request(3);
                 request(2);
             }
-            
+
             @Override
             public void onCompleted() {
-                
+
             }
 
             @Override
             public void onError(Throwable e) {
-                
+
             }
 
             @Override
@@ -481,7 +481,7 @@ public void onNext(Integer t) {
             }});
         assertEquals(Arrays.asList(1,2,3,4,5), list);
     }
-    
+
     @Test
     public void testOnStartRequestsAreAdditiveAndOverflowBecomesMaxValue() {
         final List<Integer> list = new ArrayList<Integer>();
@@ -491,15 +491,15 @@ public void onStart() {
                 request(2);
                 request(Long.MAX_VALUE-1);
             }
-            
+
             @Override
             public void onCompleted() {
-                
+
             }
 
             @Override
             public void onError(Throwable e) {
-                
+
             }
 
             @Override
diff --git a/src/test/java/rx/TestUtil.java b/src/test/java/rx/TestUtil.java
index 5d60c4758f..7beb6d0f4a 100644
--- a/src/test/java/rx/TestUtil.java
+++ b/src/test/java/rx/TestUtil.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -32,7 +32,7 @@
  */
 public enum TestUtil {
     ;
-    
+
     /**
      * Verifies that the given class has a private constructor that
      * throws IllegalStateException("No instances!") upon instantiation.
@@ -45,7 +45,7 @@ public static void checkUtilityClass(Class<?> clazz) {
             .expectedExceptionMessage("No instances!")
             .check();
     }
-    
+
     /**
      * Runs two actions concurrently, one in the current thread and the other on
      * the IO scheduler, synchronizing their execution as much as possible; rethrowing
@@ -58,24 +58,24 @@ public static void race(Action0 r1, final Action0 r2) {
         final AtomicInteger counter = new AtomicInteger(2);
         final Throwable[] errors = { null, null };
         final CountDownLatch cdl = new CountDownLatch(1);
-        
+
         Worker w = Schedulers.io().createWorker();
-        
+
         try {
-            
+
             w.schedule(new Action0() {
                 @Override
                 public void call() {
                     if (counter.decrementAndGet() != 0) {
                         while (counter.get() != 0);
                     }
-                    
+
                     try {
                         r2.call();
                     } catch (Throwable ex) {
                         errors[1] = ex;
                     }
-                    
+
                     cdl.countDown();
                 }
             });
@@ -83,15 +83,15 @@ public void call() {
             if (counter.decrementAndGet() != 0) {
                 while (counter.get() != 0);
             }
-            
+
             try {
                 r1.call();
             } catch (Throwable ex) {
                 errors[0] = ex;
             }
-            
+
             List<Throwable> errorList = new ArrayList<Throwable>();
-            
+
             try {
                 if (!cdl.await(5, TimeUnit.SECONDS)) {
                     errorList.add(new TimeoutException());
@@ -99,7 +99,7 @@ public void call() {
             } catch (InterruptedException ex) {
                 errorList.add(ex);
             }
-            
+
             if (errors[0] != null) {
                 errorList.add(errors[0]);
             }
diff --git a/src/test/java/rx/ThrottleLastTests.java b/src/test/java/rx/ThrottleLastTests.java
index 73cfe27485..3ce8d5600b 100644
--- a/src/test/java/rx/ThrottleLastTests.java
+++ b/src/test/java/rx/ThrottleLastTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/ThrottleWithTimeoutTests.java b/src/test/java/rx/ThrottleWithTimeoutTests.java
index 5bd336f74c..166d2a9b56 100644
--- a/src/test/java/rx/ThrottleWithTimeoutTests.java
+++ b/src/test/java/rx/ThrottleWithTimeoutTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -60,13 +60,13 @@ public void testThrottle() {
         inOrder.verify(observer).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @Test
     public void timed() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 2).throttleWithTimeout(1, TimeUnit.SECONDS).subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValue(2);
         ts.assertNoErrors();
diff --git a/src/test/java/rx/ZipTests.java b/src/test/java/rx/ZipTests.java
index 782fbf84d1..465319a565 100644
--- a/src/test/java/rx/ZipTests.java
+++ b/src/test/java/rx/ZipTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -101,7 +101,7 @@ public void testCovarianceOfZip() {
     /**
      * Occasionally zip may be invoked with 0 observables. Test that we don't block indefinitely instead
      * of immediately invoking zip with 0 argument.
-     * 
+     *
      * We now expect a NoSuchElementException since last() requires at least one value and nothing will be emitted.
      */
     @Test(expected = NoSuchElementException.class)
diff --git a/src/test/java/rx/exceptions/CompositeExceptionTest.java b/src/test/java/rx/exceptions/CompositeExceptionTest.java
index 9cfc7fa6dd..5451a8cf10 100644
--- a/src/test/java/rx/exceptions/CompositeExceptionTest.java
+++ b/src/test/java/rx/exceptions/CompositeExceptionTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -58,7 +58,7 @@ public void testMultipleWithSameCause() {
         System.err.println("----------------------------- print composite stacktrace");
         ce.printStackTrace();
         assertEquals(3, ce.getExceptions().size());
-        
+
         assertNoCircularReferences(ce);
         assertNotNull(getRootCause(ce));
         System.err.println("----------------------------- print cause stacktrace");
@@ -68,14 +68,14 @@ public void testMultipleWithSameCause() {
     @Test(timeout = 1000)
     public void testCompositeExceptionFromParentThenChild() {
         CompositeException cex = new CompositeException(Arrays.asList(ex1, ex2));
-        
+
         System.err.println("----------------------------- print composite stacktrace");
         cex.printStackTrace();
         assertEquals(2, cex.getExceptions().size());
-        
+
         assertNoCircularReferences(cex);
         assertNotNull(getRootCause(cex));
-        
+
         System.err.println("----------------------------- print cause stacktrace");
         cex.getCause().printStackTrace();
     }
@@ -83,14 +83,14 @@ public void testCompositeExceptionFromParentThenChild() {
     @Test(timeout = 1000)
     public void testCompositeExceptionFromChildThenParent() {
         CompositeException cex = new CompositeException(Arrays.asList(ex2, ex1));
-        
+
         System.err.println("----------------------------- print composite stacktrace");
         cex.printStackTrace();
         assertEquals(2, cex.getExceptions().size());
-        
+
         assertNoCircularReferences(cex);
         assertNotNull(getRootCause(cex));
-        
+
         System.err.println("----------------------------- print cause stacktrace");
         cex.getCause().printStackTrace();
     }
@@ -98,11 +98,11 @@ public void testCompositeExceptionFromChildThenParent() {
     @Test(timeout = 1000)
     public void testCompositeExceptionFromChildAndComposite() {
         CompositeException cex = new CompositeException(Arrays.asList(ex1, getNewCompositeExceptionWithEx123()));
-        
+
         System.err.println("----------------------------- print composite stacktrace");
         cex.printStackTrace();
         assertEquals(3, cex.getExceptions().size());
-        
+
         assertNoCircularReferences(cex);
         assertNotNull(getRootCause(cex));
 
@@ -113,11 +113,11 @@ public void testCompositeExceptionFromChildAndComposite() {
     @Test(timeout = 1000)
     public void testCompositeExceptionFromCompositeAndChild() {
         CompositeException cex = new CompositeException(Arrays.asList(getNewCompositeExceptionWithEx123(), ex1));
-        
+
         System.err.println("----------------------------- print composite stacktrace");
         cex.printStackTrace();
         assertEquals(3, cex.getExceptions().size());
-        
+
         assertNoCircularReferences(cex);
         assertNotNull(getRootCause(cex));
 
@@ -131,11 +131,11 @@ public void testCompositeExceptionFromTwoDuplicateComposites() {
         exs.add(getNewCompositeExceptionWithEx123());
         exs.add(getNewCompositeExceptionWithEx123());
         CompositeException cex = new CompositeException(exs);
-        
+
         System.err.println("----------------------------- print composite stacktrace");
         cex.printStackTrace();
         assertEquals(3, cex.getExceptions().size());
-        
+
         assertNoCircularReferences(cex);
         assertNotNull(getRootCause(cex));
 
@@ -168,7 +168,7 @@ private static Throwable getRootCause(Throwable ex) {
             }
         }
     }
-    
+
     @Test
     public void testNullCollection() {
         CompositeException composite = new CompositeException((List<Throwable>)null);
diff --git a/src/test/java/rx/exceptions/ExceptionsNullTest.java b/src/test/java/rx/exceptions/ExceptionsNullTest.java
index e704d7cf7c..5a42eca52f 100644
--- a/src/test/java/rx/exceptions/ExceptionsNullTest.java
+++ b/src/test/java/rx/exceptions/ExceptionsNullTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -25,65 +25,65 @@ public class ExceptionsNullTest {
     @Test
     public void testOnCompleteFailedExceptionNull() {
         Throwable t = new OnCompletedFailedException(null);
-        
+
         Assert.assertTrue(t.getCause() instanceof NullPointerException);
     }
-    
+
     @Test
     public void testOnCompleteFailedExceptionMessageAndNull() {
         Throwable t = new OnCompletedFailedException("Message", null);
-        
+
         Assert.assertTrue(t.getCause() instanceof NullPointerException);
     }
 
     @Test
     public void testOnErrorFailedExceptionNull() {
         Throwable t = new OnErrorFailedException(null);
-        
+
         Assert.assertTrue(t.getCause() instanceof NullPointerException);
     }
-    
+
     @Test
     public void testOnErrorFailedExceptionMessageAndNull() {
         Throwable t = new OnErrorFailedException("Message", null);
-        
+
         Assert.assertTrue(t.getCause() instanceof NullPointerException);
     }
-    
+
     @Test
     public void testUnsubscribeFailedExceptionNull() {
         Throwable t = new UnsubscribeFailedException(null);
-        
+
         Assert.assertTrue(t.getCause() instanceof NullPointerException);
     }
-    
+
     @Test
     public void testUnsubscribeFailedExceptionMessageAndNull() {
         Throwable t = new UnsubscribeFailedException("Message", null);
-        
+
         Assert.assertTrue(t.getCause() instanceof NullPointerException);
     }
 
     @Test
     public void testOnErrorNotImplementedExceptionNull() {
         Throwable t = new OnErrorNotImplementedException(null);
-        
+
         Assert.assertTrue(t.getCause() instanceof NullPointerException);
     }
-    
+
     @Test
     public void testOnErrorNotImplementedExceptionMessageAndNull() {
         Throwable t = new OnErrorNotImplementedException("Message", null);
-        
+
         Assert.assertTrue(t.getCause() instanceof NullPointerException);
     }
-    
+
     @Test
     public void testOnErrorThrowableFrom() {
         Throwable t = OnErrorThrowable.from(null);
         Assert.assertTrue(t.getCause() instanceof NullPointerException);
     }
-    
+
     @Test
     public void testOnErrorThrowableAddValueAsLastCause() {
         Throwable t = OnErrorThrowable.addValueAsLastCause(null, "value");
diff --git a/src/test/java/rx/exceptions/ExceptionsTest.java b/src/test/java/rx/exceptions/ExceptionsTest.java
index aa4ba21370..5fe0f18d69 100644
--- a/src/test/java/rx/exceptions/ExceptionsTest.java
+++ b/src/test/java/rx/exceptions/ExceptionsTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -72,7 +72,7 @@ public void testStackOverflowWouldOccur() {
         final PublishSubject<Integer> b = PublishSubject.create();
         final int MAX_STACK_DEPTH = 800;
         final AtomicInteger depth = new AtomicInteger();
-        
+
         a.subscribe(new Observer<Integer>() {
 
             @Override
@@ -104,7 +104,7 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(Integer n) {
-                if (depth.get() < MAX_STACK_DEPTH) { 
+                if (depth.get() < MAX_STACK_DEPTH) {
                     depth.set(Thread.currentThread().getStackTrace().length);
                     a.onNext(n + 1);
                 }
@@ -113,7 +113,7 @@ public void onNext(Integer n) {
         a.onNext(1);
         assertTrue(depth.get() > MAX_STACK_DEPTH);
     }
-    
+
     @Test(expected = StackOverflowError.class)
     public void testStackOverflowErrorIsThrown() {
         Observable.just(1).subscribe(new Observer<Integer>() {
diff --git a/src/test/java/rx/exceptions/OnNextValueTest.java b/src/test/java/rx/exceptions/OnNextValueTest.java
index 9342afac60..2e36c5bafd 100644
--- a/src/test/java/rx/exceptions/OnNextValueTest.java
+++ b/src/test/java/rx/exceptions/OnNextValueTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -121,47 +121,47 @@ public BadToString call(BadToString badToString) {
                 }).subscribe(observer);
 
     }
-    
+
     @Test
     public void testRenderInteger() {
         assertEquals("123", OnNextValue.renderValue(123));
     }
-    
+
     @Test
     public void testRenderByte() {
         assertEquals("10", OnNextValue.renderValue((byte) 10));
     }
-    
+
     @Test
     public void testRenderBoolean() {
         assertEquals("true", OnNextValue.renderValue(true));
     }
-    
+
     @Test
     public void testRenderShort() {
         assertEquals("10", OnNextValue.renderValue((short) 10));
     }
-    
+
     @Test
     public void testRenderLong() {
         assertEquals("10", OnNextValue.renderValue(10L));
     }
-    
+
     @Test
     public void testRenderCharacter() {
         assertEquals("10", OnNextValue.renderValue(10L));
     }
-    
+
     @Test
     public void testRenderFloat() {
         assertEquals("10.0", OnNextValue.renderValue(10.0f));
     }
-    
+
     @Test
     public void testRenderDouble() {
         assertEquals("10.0", OnNextValue.renderValue(10.0));
     }
-    
+
     @Test
     public void testRenderVoid() {
         assertEquals("null", OnNextValue.renderValue((Void) null));
diff --git a/src/test/java/rx/exceptions/TestException.java b/src/test/java/rx/exceptions/TestException.java
index 16422b7f25..b513b3c54e 100644
--- a/src/test/java/rx/exceptions/TestException.java
+++ b/src/test/java/rx/exceptions/TestException.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/functions/ActionsTest.java b/src/test/java/rx/functions/ActionsTest.java
index 0e6e2dc5dc..aaddbf3fbf 100644
--- a/src/test/java/rx/functions/ActionsTest.java
+++ b/src/test/java/rx/functions/ActionsTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -30,10 +30,10 @@ public class ActionsTest {
     public void testEmptyArities() {
         Action0 a0 = Actions.empty();
         a0.call();
-        
+
         Action1<Integer> a1 = Actions.empty();
         a1.call(1);
-        
+
         Action2<Integer, Integer> a2 = Actions.empty();
         a2.call(1, 2);
 
@@ -42,7 +42,7 @@ public void testEmptyArities() {
 
         Action4<Integer, Integer, Integer, Integer> a4 = Actions.empty();
         a4.call(1, 2, 3, 4);
-        
+
         Action5<Integer, Integer, Integer, Integer, Integer> a5 = Actions.empty();
         a5.call(1, 2, 3, 4, 5);
 
@@ -68,10 +68,10 @@ public void testEmptyArities() {
         ann.call(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 
         ActionN annn = Actions.empty();
-        annn.call(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 
+        annn.call(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
                 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
     }
-    
+
     @Test
     public void testToFunc0() {
         final AtomicLong value = new AtomicLong(-1L);
@@ -81,14 +81,14 @@ public void call() {
                 value.set(0);
             }
         };
-        
+
         assertNull(Actions.toFunc(action).call());
         assertEquals(0, value.get());
         value.set(-1L);
         assertEquals((Integer)0, Actions.toFunc(action, 0).call());
         assertEquals(0, value.get());
     }
-    
+
     @Test
     public void testToFunc1() {
         final AtomicLong value = new AtomicLong(-1L);
@@ -98,14 +98,14 @@ public void call(Integer t1) {
                 value.set(t1);
             }
         };
-        
+
         assertNull(Actions.toFunc(action).call(1));
         assertEquals(1, value.get());
         value.set(-1L);
         assertEquals((Integer)0, Actions.toFunc(action, 0).call(1));
         assertEquals(1, value.get());
     }
-    
+
     @Test
     public void testToFunc2() {
         final AtomicLong value = new AtomicLong(-1L);
@@ -115,7 +115,7 @@ public void call(Integer t1, Integer t2) {
                 value.set(t1 | t2);
             }
         };
-        
+
         assertNull(Actions.toFunc(action).call(1, 2));
         assertNull(Actions.toFunc(action).call(1, 2));
         assertEquals(3, value.get());
@@ -123,7 +123,7 @@ public void call(Integer t1, Integer t2) {
         assertEquals((Integer)0, Actions.toFunc(action, 0).call(1, 2));
         assertEquals(3, value.get());
     }
-    
+
     @Test
     public void testToFunc3() {
         final AtomicLong value = new AtomicLong(-1L);
@@ -133,14 +133,14 @@ public void call(Integer t1, Integer t2, Integer t3) {
                 value.set(t1 | t2 | t3);
             }
         };
-        
+
         assertNull(Actions.toFunc(action).call(1, 2, 4));
         assertEquals(7, value.get());
         value.set(-1L);
         assertEquals((Integer)0, Actions.toFunc(action, 0).call(1, 2, 4));
         assertEquals(7, value.get());
     }
-    
+
     @Test
     public void testToFunc4() {
         final AtomicLong value = new AtomicLong(-1L);
@@ -150,61 +150,61 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4) {
                 value.set(t1 | t2 | t3 | t4);
             }
         };
-        
+
         assertNull(Actions.toFunc(action).call(1, 2, 4, 8));
         assertEquals(15, value.get());
         value.set(-1L);
         assertEquals((Integer)0, Actions.toFunc(action, 0).call(1, 2, 4, 8));
         assertEquals(15, value.get());
     }
-    
+
     @Test
     public void testToFunc5() {
         final AtomicLong value = new AtomicLong(-1L);
-        final Action5<Integer, Integer, Integer, Integer, Integer> action = 
+        final Action5<Integer, Integer, Integer, Integer, Integer> action =
                 new Action5<Integer, Integer, Integer, Integer, Integer>() {
             @Override
             public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5) {
                 value.set(t1 | t2 | t3 | t4 | t5);
             }
         };
-        
+
         assertNull(Actions.toFunc(action).call(1, 2, 4, 8, 16));
         assertEquals(31, value.get());
         value.set(-1L);
         assertEquals((Integer)0, Actions.toFunc(action, 0).call(1, 2, 4, 8, 16));
         assertEquals(31, value.get());
     }
-    
+
     @Test
     public void testToFunc6() {
         final AtomicLong value = new AtomicLong(-1L);
-        final Action6<Integer, Integer, Integer, Integer, Integer, Integer> action = 
+        final Action6<Integer, Integer, Integer, Integer, Integer, Integer> action =
                 new Action6<Integer, Integer, Integer, Integer, Integer, Integer>() {
             @Override
             public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6) {
                 value.set(t1 | t2 | t3 | t4 | t5 | t6);
             }
         };
-        
+
         assertNull(Actions.toFunc(action).call(1, 2, 4, 8, 16, 32));
         assertEquals(63, value.get());
         value.set(-1L);
         assertEquals((Integer)0, Actions.toFunc(action, 0).call(1, 2, 4, 8, 16, 32));
         assertEquals(63, value.get());
     }
-    
+
     @Test
     public void testToFunc7() {
         final AtomicLong value = new AtomicLong(-1L);
-        final Action7<Integer, Integer, Integer, Integer, Integer, Integer, Integer> action = 
+        final Action7<Integer, Integer, Integer, Integer, Integer, Integer, Integer> action =
                 new Action7<Integer, Integer, Integer, Integer, Integer, Integer, Integer>() {
             @Override
             public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7) {
                 value.set(t1 | t2 | t3 | t4 | t5 | t6 | t7);
             }
         };
-        
+
         assertNull(Actions.toFunc(action).call(1, 2, 4, 8, 16, 32, 64));
         assertEquals(127, value.get());
         value.set(-1L);
@@ -214,14 +214,14 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Int
     @Test
     public void testToFunc8() {
         final AtomicLong value = new AtomicLong(-1L);
-        final Action8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> action = 
+        final Action8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> action =
                 new Action8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>() {
             @Override
             public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8) {
                 value.set(t1 | t2 | t3 | t4 | t5 | t6 | t7 | t8);
             }
         };
-        
+
         assertNull(Actions.toFunc(action).call(1, 2, 4, 8, 16, 32, 64, 128));
         assertEquals(255, value.get());
         value.set(-1L);
@@ -231,21 +231,21 @@ public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Int
     @Test
     public void testToFunc9() {
         final AtomicLong value = new AtomicLong(-1L);
-        final Action9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> action = 
+        final Action9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> action =
                 new Action9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>() {
             @Override
             public void call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8, Integer t9) {
                 value.set(t1 | t2 | t3 | t4 | t5 | t6 | t7 | t8 | t9);
             }
         };
-        
+
         assertNull(Actions.toFunc(action).call(1, 2, 4, 8, 16, 32, 64, 128, 256));
         assertEquals(511, value.get());
         value.set(-1L);
         assertEquals((Integer)0, Actions.toFunc(action, 0).call(1, 2, 4, 8, 16, 32, 64, 128, 256));
         assertEquals(511, value.get());
     }
-    
+
     @Test
     public void testToFuncN() {
         for (int i = 0; i < 100; i++) {
@@ -262,7 +262,7 @@ public void call(Object... args) {
             };
             Object[] arr = new Object[i];
             Arrays.fill(arr, 1);
-            
+
             assertNull(Actions.toFunc(action).call(arr));
             assertEquals(i, value.get());
             value.set(-1L);
@@ -270,7 +270,7 @@ public void call(Object... args) {
             assertEquals(i, value.get());
         }
     }
-    
+
     @Test
     public void constructorShouldBePrivate() {
         TestUtil.checkUtilityClass(Actions.class);
diff --git a/src/test/java/rx/functions/FunctionsTest.java b/src/test/java/rx/functions/FunctionsTest.java
index 819edcda85..61e61934de 100644
--- a/src/test/java/rx/functions/FunctionsTest.java
+++ b/src/test/java/rx/functions/FunctionsTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -29,7 +29,7 @@ public class FunctionsTest {
     public void constructorShouldBePrivate() {
         TestUtil.checkUtilityClass(Functions.class);
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromFunc0() {
         Func0<Integer> func = new Func0<Integer>() {
@@ -38,13 +38,13 @@ public Integer call() {
                 return 0;
             }
         };
-        
+
         Object[] params = new Object[0];
         assertEquals((Integer)0, Functions.fromFunc(func).call(params));
-        
+
         Functions.fromFunc(func).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromFunc1() {
         Func1<Integer, Integer> func = new Func1<Integer, Integer>() {
@@ -53,13 +53,13 @@ public Integer call(Integer t1) {
                 return t1;
             }
         };
-        
+
         Object[] params = new Object[] { 1 };
         assertEquals((Integer)1, Functions.fromFunc(func).call(params));
-        
+
         Functions.fromFunc(func).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromFunc2() {
         Func2<Integer, Integer, Integer> func = new Func2<Integer, Integer, Integer>() {
@@ -68,13 +68,13 @@ public Integer call(Integer t1, Integer t2) {
                 return t1 | t2;
             }
         };
-        
+
         Object[] params = new Object[] { 1, 2 };
         assertEquals((Integer)3, Functions.fromFunc(func).call(params));
-        
+
         Functions.fromFunc(func).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromFunc3() {
         Func3<Integer, Integer, Integer, Integer> func = new Func3<Integer, Integer, Integer, Integer>() {
@@ -83,109 +83,109 @@ public Integer call(Integer t1, Integer t2, Integer t3) {
                 return t1 | t2 | t3;
             }
         };
-        
+
         Object[] params = new Object[] { 1, 2, 4 };
         assertEquals((Integer)7, Functions.fromFunc(func).call(params));
-        
+
         Functions.fromFunc(func).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromFunc4() {
-        Func4<Integer, Integer, Integer, Integer, Integer> func = 
+        Func4<Integer, Integer, Integer, Integer, Integer> func =
                 new Func4<Integer, Integer, Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2, Integer t3, Integer t4) {
                 return t1 | t2 | t3 | t4;
             }
         };
-        
+
         Object[] params = new Object[] { 1, 2, 4, 8 };
         assertEquals((Integer)15, Functions.fromFunc(func).call(params));
-        
+
         Functions.fromFunc(func).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromFunc5() {
-        Func5<Integer, Integer, Integer, Integer, Integer, Integer> func = 
+        Func5<Integer, Integer, Integer, Integer, Integer, Integer> func =
                 new Func5<Integer, Integer, Integer, Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5) {
                 return t1 | t2 | t3 | t4 | t5;
             }
         };
-        
+
         Object[] params = new Object[] { 1, 2, 4, 8, 16 };
         assertEquals((Integer)31, Functions.fromFunc(func).call(params));
-        
+
         Functions.fromFunc(func).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromFunc6() {
-        Func6<Integer, Integer, Integer, Integer, Integer, Integer, Integer> func = 
+        Func6<Integer, Integer, Integer, Integer, Integer, Integer, Integer> func =
                 new Func6<Integer, Integer, Integer, Integer, Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6) {
                 return t1 | t2 | t3 | t4 | t5 | t6;
             }
         };
-        
+
         Object[] params = new Object[] { 1, 2, 4, 8, 16, 32 };
         assertEquals((Integer)63, Functions.fromFunc(func).call(params));
-        
+
         Functions.fromFunc(func).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromFunc7() {
-        Func7<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> func = 
+        Func7<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> func =
                 new Func7<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7) {
                 return t1 | t2 | t3 | t4 | t5 | t6 | t7;
             }
         };
-        
+
         Object[] params = new Object[] { 1, 2, 4, 8, 16, 32, 64 };
         assertEquals((Integer)127, Functions.fromFunc(func).call(params));
-        
+
         Functions.fromFunc(func).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromFunc8() {
-        Func8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> func = 
+        Func8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> func =
                 new Func8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8) {
                 return t1 | t2 | t3 | t4 | t5 | t6 | t7 | t8;
             }
         };
-        
+
         Object[] params = new Object[] { 1, 2, 4, 8, 16, 32, 64, 128 };
         assertEquals((Integer)255, Functions.fromFunc(func).call(params));
-        
+
         Functions.fromFunc(func).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromFunc9() {
-        Func9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> func = 
+        Func9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> func =
                 new Func9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8, Integer t9) {
                 return t1 | t2 | t3 | t4 | t5 | t6 | t7 | t8 | t9;
             }
         };
-        
+
         Object[] params = new Object[] { 1, 2, 4, 8, 16, 32, 64, 128, 256 };
         assertEquals((Integer)511, Functions.fromFunc(func).call(params));
-        
+
         Functions.fromFunc(func).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromAction0() {
         final AtomicLong value = new AtomicLong();
@@ -195,14 +195,14 @@ public void call() {
                 value.set(0);
             }
         };
-        
+
         Object[] params = new Object[] { };
         Functions.fromAction(action).call(params);
         assertEquals(0, value.get());
-        
+
         Functions.fromAction(action).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromAction1() {
         final AtomicLong value = new AtomicLong();
@@ -212,14 +212,14 @@ public void call(Integer t1) {
                 value.set(t1);
             }
         };
-        
+
         Object[] params = new Object[] { 1 };
         Functions.fromAction(action).call(params);
         assertEquals(1, value.get());
-        
+
         Functions.fromAction(action).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromAction2() {
         final AtomicLong value = new AtomicLong();
@@ -229,14 +229,14 @@ public void call(Integer t1, Integer t2) {
                 value.set(t1 | t2);
             }
         };
-        
+
         Object[] params = new Object[] { 1, 2 };
         Functions.fromAction(action).call(params);
         assertEquals(3, value.get());
-        
+
         Functions.fromAction(action).call(Arrays.copyOf(params, params.length + 1));
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testFromAction3() {
         final AtomicLong value = new AtomicLong();
@@ -246,11 +246,11 @@ public void call(Integer t1, Integer t2, Integer t3) {
                 value.set(t1 | t2 | t3);
             }
         };
-        
+
         Object[] params = new Object[] { 1, 2, 4 };
         Functions.fromAction(action).call(params);
         assertEquals(7, value.get());
-        
+
         Functions.fromAction(action).call(Arrays.copyOf(params, params.length + 1));
     }
 }
diff --git a/src/test/java/rx/internal/operators/BackpressureUtilsTest.java b/src/test/java/rx/internal/operators/BackpressureUtilsTest.java
index 6501a71792..f158fc8192 100644
--- a/src/test/java/rx/internal/operators/BackpressureUtilsTest.java
+++ b/src/test/java/rx/internal/operators/BackpressureUtilsTest.java
@@ -35,7 +35,7 @@ public void testAddCap() {
         assertEquals(Long.MAX_VALUE, BackpressureUtils.addCap(Long.MAX_VALUE - 1, Long.MAX_VALUE - 1));
         assertEquals(Long.MAX_VALUE, BackpressureUtils.addCap(Long.MAX_VALUE, Long.MAX_VALUE));
     }
-    
+
     @Test
     public void testMultiplyCap() {
         assertEquals(6, BackpressureUtils.multiplyCap(2, 3));
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java b/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
index bd07f55226..8244bf9c48 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorLatestTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java b/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java
index 4592e96e95..b814c50973 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorMostRecentTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
index 56fb66965b..45a109e885 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -229,7 +229,7 @@ public void testNextWithCallingHasNextMultipleTimes() {
      * Confirm that no buffering or blocking of the Observable onNext calls occurs and it just grabs the next emitted value.
      * <p/>
      * This results in output such as => a: 1 b: 2 c: 89
-     * 
+     *
      * @throws Throwable
      */
     @Test
@@ -266,34 +266,34 @@ public void run() {
 
         try {
             Iterator<Integer> it = next(obs).iterator();
-    
+
             assertTrue(it.hasNext());
             int a = it.next();
             assertTrue(it.hasNext());
             int b = it.next();
             // we should have a different value
             assertTrue("a and b should be different", a != b);
-    
+
             // wait for some time (if times out we are blocked somewhere so fail ... set very high for very slow, constrained machines)
             timeHasPassed.await(8000, TimeUnit.MILLISECONDS);
-    
+
             assertTrue(it.hasNext());
             int c = it.next();
-    
+
             assertTrue("c should not just be the next in sequence", c != (b + 1));
             assertTrue("expected that c [" + c + "] is higher than or equal to " + COUNT, c >= COUNT);
-    
+
             assertTrue(it.hasNext());
             int d = it.next();
             assertTrue(d > c);
-    
+
             // shut down the thread
             running.set(false);
-    
+
             finished.await();
-    
+
             assertFalse(it.hasNext());
-    
+
             System.out.println("a: " + a + " b: " + b + " c: " + c);
         } finally {
             running.set(false); // don't let the thread spin indefinitely
@@ -318,7 +318,7 @@ public void testSingleSourceManyIterators() throws InterruptedException {
             terminal.onNext(null);
         }
     }
-    
+
     @Test
     public void testSynchronousNext() {
         assertEquals(1, BehaviorSubject.create(1).take(1).toBlocking().single().intValue());
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java b/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
index f4a96834ab..5a85995d7b 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java b/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
index 07a5529a5e..e641227f01 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/CachedObservableTest.java b/src/test/java/rx/internal/operators/CachedObservableTest.java
index b1ef245485..a642d80b03 100644
--- a/src/test/java/rx/internal/operators/CachedObservableTest.java
+++ b/src/test/java/rx/internal/operators/CachedObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -36,16 +36,16 @@ public class CachedObservableTest {
     @Test
     public void testColdReplayNoBackpressure() {
         CachedObservable<Integer> source = CachedObservable.from(Observable.range(0, 1000));
-        
+
         assertFalse("Source is connected!", source.isConnected());
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.subscribe(ts);
 
         assertTrue("Source is not connected!", source.isConnected());
         assertFalse("Subscribers retained!", source.hasObservers());
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         List<Integer> onNextEvents = ts.getOnNextEvents();
@@ -58,17 +58,17 @@ public void testColdReplayNoBackpressure() {
     @Test
     public void testColdReplayBackpressure() {
         CachedObservable<Integer> source = CachedObservable.from(Observable.range(0, 1000));
-        
+
         assertFalse("Source is connected!", source.isConnected());
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         ts.requestMore(10);
-        
+
         source.subscribe(ts);
 
         assertTrue("Source is not connected!", source.isConnected());
         assertTrue("Subscribers not retained!", source.hasObservers());
-        
+
         ts.assertNoErrors();
         assertEquals(0, ts.getCompletions());
         List<Integer> onNextEvents = ts.getOnNextEvents();
@@ -77,11 +77,11 @@ public void testColdReplayBackpressure() {
         for (int i = 0; i < 10; i++) {
             assertEquals((Integer)i, onNextEvents.get(i));
         }
-        
+
         ts.unsubscribe();
         assertFalse("Subscribers retained!", source.hasObservers());
     }
-    
+
     @Test
     public void testCache() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
@@ -142,39 +142,39 @@ public void testUnsubscribeSource() {
         o.subscribe();
         verify(unsubscribe, times(1)).call();
     }
-    
+
     @Test
     public void testTake() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
 
         CachedObservable<Integer> cached = CachedObservable.from(Observable.range(1, 100));
         cached.take(10).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
         ts.assertUnsubscribed();
         assertFalse(cached.hasObservers());
     }
-    
+
     @Test
     public void testAsync() {
         Observable<Integer> source = Observable.range(1, 10000);
         for (int i = 0; i < 100; i++) {
             TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>();
-            
+
             CachedObservable<Integer> cached = CachedObservable.from(source);
-            
+
             cached.observeOn(Schedulers.computation()).subscribe(ts1);
-            
+
             ts1.awaitTerminalEvent(2, TimeUnit.SECONDS);
             ts1.assertNoErrors();
             ts1.assertTerminalEvent();
             assertEquals(10000, ts1.getOnNextEvents().size());
-            
+
             TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>();
             cached.observeOn(Schedulers.computation()).subscribe(ts2);
-            
+
             ts2.awaitTerminalEvent(2, TimeUnit.SECONDS);
             ts2.assertNoErrors();
             ts2.assertTerminalEvent();
@@ -187,9 +187,9 @@ public void testAsyncComeAndGo() {
                 .take(1000)
                 .subscribeOn(Schedulers.io());
         CachedObservable<Long> cached = CachedObservable.from(source);
-        
+
         Observable<Long> output = cached.observeOn(Schedulers.computation());
-        
+
         List<TestSubscriber<Long>> list = new ArrayList<TestSubscriber<Long>>(100);
         for (int i = 0; i < 100; i++) {
             TestSubscriber<Long> ts = new TestSubscriber<Long>();
@@ -206,17 +206,17 @@ public void testAsyncComeAndGo() {
             ts.awaitTerminalEvent(3, TimeUnit.SECONDS);
             ts.assertNoErrors();
             ts.assertTerminalEvent();
-            
+
             for (int i = j * 10; i < j * 10 + 10; i++) {
                 expected.set(i - j * 10, (long)i);
             }
-            
+
             ts.assertReceivedOnNext(expected);
-            
+
             j++;
         }
     }
-    
+
     @Test
     public void testNoMissingBackpressureException() {
         final int m = 4 * 1000 * 1000;
@@ -229,43 +229,43 @@ public void call(Subscriber<? super Integer> t) {
                 t.onCompleted();
             }
         });
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         firehose.cache().observeOn(Schedulers.computation()).takeLast(100).subscribe(ts);
-        
+
         ts.awaitTerminalEvent(3, TimeUnit.SECONDS);
         ts.assertNoErrors();
         ts.assertTerminalEvent();
-        
+
         assertEquals(100, ts.getOnNextEvents().size());
     }
-    
+
     @Test
     public void testValuesAndThenError() {
         Observable<Integer> source = Observable.range(1, 10)
                 .concatWith(Observable.<Integer>error(new TestException()))
                 .cache();
-        
-        
+
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         source.subscribe(ts);
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
         Assert.assertEquals(0, ts.getCompletions());
         Assert.assertEquals(1, ts.getOnErrorEvents().size());
-        
+
         TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>();
         source.subscribe(ts2);
-        
+
         ts2.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
         Assert.assertEquals(0, ts2.getCompletions());
         Assert.assertEquals(1, ts2.getOnErrorEvents().size());
     }
-    
+
     @Test
     public void unsafeChildThrows() {
         final AtomicInteger count = new AtomicInteger();
-        
+
         Observable<Integer> source = Observable.range(1, 100)
         .doOnNext(new Action1<Integer>() {
             @Override
@@ -274,16 +274,16 @@ public void call(Integer t) {
             }
         })
         .cache();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
                 throw new TestException();
             }
         };
-        
+
         source.unsafeSubscribe(ts);
-        
+
         Assert.assertEquals(100, count.get());
 
         ts.assertNoValues();
diff --git a/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java b/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
index d7ef2c3217..8d1600c69d 100644
--- a/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
+++ b/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -34,14 +34,14 @@ public class CompletableFromEmitterTest {
     @Test
     public void normal() {
         TestSubscriber<Void> ts = TestSubscriber.create();
-        
+
         Completable.fromEmitter(new Action1<CompletableEmitter>() {
             @Override
             public void call(CompletableEmitter e) {
                 e.onCompleted();
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -50,23 +50,23 @@ public void call(CompletableEmitter e) {
     @Test
     public void error() {
         TestSubscriber<Void> ts = TestSubscriber.create();
-        
+
         Completable.fromEmitter(new Action1<CompletableEmitter>() {
             @Override
             public void call(CompletableEmitter e) {
                 e.onError(new TestException());
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
-    public void ensureProtocol1() { 
+    public void ensureProtocol1() {
         TestSubscriber<Void> ts = TestSubscriber.create();
-        
+
         Completable.fromEmitter(new Action1<CompletableEmitter>() {
             @Override
             public void call(CompletableEmitter e) {
@@ -75,16 +75,16 @@ public void call(CompletableEmitter e) {
                 e.onError(new IOException());
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
 
     @Test
-    public void ensureProtocol2() { 
+    public void ensureProtocol2() {
         TestSubscriber<Void> ts = TestSubscriber.create();
-        
+
         Completable.fromEmitter(new Action1<CompletableEmitter>() {
             @Override
             public void call(CompletableEmitter e) {
@@ -93,7 +93,7 @@ public void call(CompletableEmitter e) {
                 e.onCompleted();
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -114,14 +114,14 @@ public void call(CompletableEmitter e) {
                 e.onCompleted();
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         assertTrue(bs.isUnsubscribed());
     }
-    
+
     @Test
     public void resourceCleanupError() {
         TestSubscriber<Void> ts = TestSubscriber.create();
@@ -137,14 +137,14 @@ public void call(CompletableEmitter e) {
                 e.onError(new TestException());
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
-        
+
         assertTrue(bs.isUnsubscribed());
     }
-    
+
     @Test
     public void resourceCleanupCancellable() throws Exception {
         TestSubscriber<Void> ts = TestSubscriber.create();
@@ -158,14 +158,14 @@ public void call(CompletableEmitter e) {
                 e.onCompleted();
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
 
         Mockito.verify(c).cancel();
     }
-    
+
     @Test
     public void resourceCleanupUnsubscirbe() throws Exception {
         TestSubscriber<Void> ts = TestSubscriber.create();
@@ -180,14 +180,14 @@ public void call(CompletableEmitter e) {
                 e.onCompleted();
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
 
         Mockito.verify(c).cancel();
     }
-    
+
     @Test
     public void resourceCleanupOnCompleteCrashes() throws Exception {
         final AsyncEmitter.Cancellable c = Mockito.mock(AsyncEmitter.Cancellable.class);
@@ -212,15 +212,15 @@ public void onError(Throwable e) {
 
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
         });
-        
+
 
         Mockito.verify(c).cancel();
     }
-    
+
     @Test
     public void resourceCleanupOnErrorCrashes() throws Exception {
         final AsyncEmitter.Cancellable c = Mockito.mock(AsyncEmitter.Cancellable.class);
@@ -245,25 +245,25 @@ public void onError(Throwable e) {
 
             @Override
             public void onSubscribe(Subscription d) {
-                
+
             }
-            
+
         });
-        
+
 
         Mockito.verify(c).cancel();
     }
     @Test
     public void producerCrashes() {
         TestSubscriber<Void> ts = TestSubscriber.create();
-        
+
         Completable.fromEmitter(new Action1<CompletableEmitter>() {
             @Override
             public void call(CompletableEmitter e) {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -272,7 +272,7 @@ public void call(CompletableEmitter e) {
     @Test
     public void producerCrashesAfterSignal() {
         TestSubscriber<Void> ts = TestSubscriber.create();
-        
+
         Completable.fromEmitter(new Action1<CompletableEmitter>() {
             @Override
             public void call(CompletableEmitter e) {
@@ -280,41 +280,41 @@ public void call(CompletableEmitter e) {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void concurrentUse() {
         for (int i = 0; i < 500; i++) {
             TestSubscriber<Void> ts = TestSubscriber.create();
-            
+
             final CompletableEmitter[] emitter = { null };
-            
+
             Completable.fromEmitter(new Action1<CompletableEmitter>() {
                 @Override
                 public void call(CompletableEmitter e) {
                     emitter[0] = e;
                 }
             }).subscribe(ts);
-            
+
             final TestException ex = new TestException();
             final CompletableEmitter e = emitter[0];
-            
+
             TestUtil.race(new Action0() {
                 @Override
-                public void call() { 
+                public void call() {
                     e.onCompleted();
                 }
             }, new Action0() {
                 @Override
-                public void call() { 
+                public void call() {
                     e.onError(ex);
                 }
             });
-            
+
             if (ts.getCompletions() != 0) {
                 ts.assertNoValues();
                 ts.assertNoErrors();
diff --git a/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java b/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
index 59c52ac17e..6d09cfb950 100644
--- a/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
+++ b/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
@@ -38,84 +38,84 @@ public void completeFirst() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0L);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.setupDownstream();
-        
+
         ds.onNext(1);
 
         ts.assertNoValues();
 
         ds.onCompleted();
-        
+
         ts.assertNoValues();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void requestFirst() {
         TestSubscriber<Integer> ts = TestSubscriber.create(1);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.setupDownstream();
-        
+
         ds.onNext(1);
 
         ts.assertNoValues();
-        
+
         ds.onCompleted();
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void empty() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0L);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.setupDownstream();
-        
+
         ts.assertNoValues();
 
         ds.onCompleted();
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void error() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0L);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.setupDownstream();
-        
+
         ts.assertNoValues();
 
         ds.onError(new TestException());
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void unsubscribeComposes() {
         PublishSubject<Integer> ps = PublishSubject.create();
         TestSubscriber<Integer> ts = TestSubscriber.create(0L);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
-        
+
         ds.subscribeTo(ps);
-        
+
         assertTrue("No subscribers?", ps.hasObservers());
-        
+
         ts.unsubscribe();
-        
+
         ds.onNext(1);
         ds.onCompleted();
-        
+
         ts.requestMore(1);
 
         ts.assertNoValues();
@@ -125,30 +125,30 @@ public void unsubscribeComposes() {
         assertFalse("Subscribers?", ps.hasObservers());
         assertTrue("Deferred not unsubscribed?", ds.isUnsubscribed());
     }
-    
+
     @Test
     public void emptySource() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0L);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.subscribeTo(Observable.just(1).ignoreElements()); // we need a producer from upstream
-        
+
         ts.assertNoValues();
 
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void justSource() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0L);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.subscribeTo(Observable.just(1));
-        
+
         ts.assertNoValues();
 
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -159,11 +159,11 @@ public void rangeSource() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.subscribeTo(Observable.range(1, 10));
-        
+
         ts.assertNoValues();
 
         ts.requestMore(1);
-        
+
         ts.assertValue(10);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -181,16 +181,16 @@ public void onNext(Integer t) {
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.setupDownstream();
         ds.onNext(1);
-        
+
         ts.assertNoValues();
 
         ds.onCompleted();
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void completeAfterNextViaRequest() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L) {
@@ -204,71 +204,71 @@ public void onNext(Integer t) {
         ds.setupDownstream();
         ds.onNext(1);
         ds.onCompleted();
-        
+
         ts.assertNoValues();
 
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void doubleComplete() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.setupDownstream();
-        
+
         ds.onNext(1);
-        
+
         ts.requestMore(1);
-        
+
         ds.onCompleted();
         ds.onCompleted();
-        
-        
+
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void doubleComplete2() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.setupDownstream();
-        
+
         ds.onNext(1);
-        
+
         ds.onCompleted();
         ds.onCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void doubleRequest() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.setupDownstream();
-        
+
         ds.onNext(1);
-        
+
         ts.requestMore(1);
         ts.requestMore(1);
-        
+
         ds.onCompleted();
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void negativeRequest() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
@@ -288,14 +288,14 @@ public void callsAfterUnsubscribe() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
         TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
         ds.setupDownstream();
-        
+
         ts.unsubscribe();
-        
+
         ds.downstreamRequest(1);
         ds.onNext(1);
         ds.onCompleted();
         ds.onCompleted();
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -305,14 +305,14 @@ public void emissionRequestRace() {
         Worker w = Schedulers.computation().createWorker();
         try {
             for (int i = 0; i < 10000; i++) {
-    
+
                 final TestSubscriber<Integer> ts = TestSubscriber.create(0L);
                 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
                 ds.setupDownstream();
                 ds.onNext(1);
-    
+
                 final AtomicInteger ready = new AtomicInteger(2);
-                
+
                 w.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -322,23 +322,23 @@ public void call() {
                         ts.requestMore(1);
                     }
                 });
-                
+
                 ready.decrementAndGet();
                 while (ready.get() != 0) ;
-                
+
                 ds.onCompleted();
-                
+
                 ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
                 ts.assertValues(1);
                 ts.assertNoErrors();
                 ts.assertCompleted();
-    
+
             }
         } finally {
             w.unsubscribe();
         }
     }
-    
+
     @Test
     public void emissionRequestRace2() {
         Worker w = Schedulers.io().createWorker();
@@ -349,14 +349,14 @@ public void emissionRequestRace2() {
         }
         try {
             for (int i = 0; i < m; i++) {
-    
+
                 final TestSubscriber<Integer> ts = TestSubscriber.create(0L);
                 TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
                 ds.setupDownstream();
                 ds.onNext(1);
-    
+
                 final AtomicInteger ready = new AtomicInteger(3);
-                
+
                 w.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -379,21 +379,21 @@ public void call() {
 
                 ready.decrementAndGet();
                 while (ready.get() != 0) ;
-                
+
                 ds.onCompleted();
-                
+
                 ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
                 ts.assertValues(1);
                 ts.assertNoErrors();
                 ts.assertCompleted();
-    
+
             }
         } finally {
             w.unsubscribe();
             w2.unsubscribe();
         }
     }
-    
+
     static final class TestingDeferredScalarSubscriber extends DeferredScalarSubscriber<Integer, Integer> {
 
         public TestingDeferredScalarSubscriber(Subscriber<? super Integer> actual) {
diff --git a/src/test/java/rx/internal/operators/NotificationLiteTest.java b/src/test/java/rx/internal/operators/NotificationLiteTest.java
index 9b9f3f7661..ed6e3cb768 100644
--- a/src/test/java/rx/internal/operators/NotificationLiteTest.java
+++ b/src/test/java/rx/internal/operators/NotificationLiteTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -29,23 +29,23 @@ public void testComplete() {
         NotificationLite<Object> on = NotificationLite.instance();
         Object n = on.next("Hello");
         Object c = on.completed();
-        
+
         assertTrue(on.isCompleted(c));
         assertFalse(on.isCompleted(n));
-        
+
         assertEquals("Hello", on.getValue(n));
     }
-    
+
     @Test
     public void testValueKind() {
         NotificationLite<Object> on = NotificationLite.instance();
-        
+
         assertTrue(on.isNull(on.next(null)));
         assertFalse(on.isNull(on.next(1)));
         assertFalse(on.isNull(on.error(new TestException())));
         assertFalse(on.isNull(on.completed()));
         assertFalse(on.isNull(null));
-        
+
         assertTrue(on.isNext(on.next(null)));
         assertTrue(on.isNext(on.next(1)));
         assertFalse(on.isNext(on.completed()));
diff --git a/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java b/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java
index 0f70bd633c..c3e7480fa7 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -215,8 +215,8 @@ public void testBackpressure() {
         ts.assertNoErrors();
         assertEquals(RxRingBuffer.SIZE * 2, ts.getOnNextEvents().size());
     }
-    
-    
+
+
     @Test
     public void testSubscriptionOnlyHappensOnce() throws InterruptedException {
         final AtomicLong count = new AtomicLong();
@@ -239,7 +239,7 @@ public void call() {
         ts.assertNoErrors();
         assertEquals(2, count.get());
     }
-    
+
     @Test
     public void testSecondaryRequestsPropagatedToChildren() throws InterruptedException {
         //this aync stream should emit first
@@ -289,13 +289,13 @@ public void testMultipleUse() {
         TestSubscriber<Long> ts2 = new TestSubscriber<Long>();
 
         Observable<Long> amb = Observable.timer(100, TimeUnit.MILLISECONDS).ambWith(Observable.timer(200, TimeUnit.MILLISECONDS));
-        
+
         amb.subscribe(ts1);
         amb.subscribe(ts2);
-        
+
         ts1.awaitTerminalEvent();
         ts2.awaitTerminalEvent();
-        
+
         ts1.assertValue(0L);
         ts1.assertCompleted();
         ts1.assertNoErrors();
@@ -304,22 +304,22 @@ public void testMultipleUse() {
         ts2.assertCompleted();
         ts2.assertNoErrors();
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void ambIterable() {
         PublishSubject<Integer> ps1 = PublishSubject.create();
         PublishSubject<Integer> ps2 = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.amb(Arrays.asList(ps1, ps2)).subscribe(ts);
-        
+
         ts.assertNoValues();
-        
+
         ps1.onNext(1);
         ps1.onCompleted();
-        
+
         assertFalse(ps1.hasObservers());
         assertFalse(ps2.hasObservers());
 
@@ -327,22 +327,22 @@ public void ambIterable() {
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void ambIterable2() {
         PublishSubject<Integer> ps1 = PublishSubject.create();
         PublishSubject<Integer> ps2 = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.amb(Arrays.asList(ps1, ps2)).subscribe(ts);
-        
+
         ts.assertNoValues();
-        
+
         ps2.onNext(2);
         ps2.onCompleted();
-        
+
         assertFalse(ps1.hasObservers());
         assertFalse(ps2.hasObservers());
 
@@ -350,7 +350,7 @@ public void ambIterable2() {
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void ambMany() throws Exception {
@@ -361,37 +361,37 @@ public void ambMany() throws Exception {
             PublishSubject<Integer>[] ps = new PublishSubject[i];
 
             for (int j = 0; j < i; j++) {
-                
+
                 for (int k = 0; k < i; k++) {
                     ps[k] = PublishSubject.create();
                 }
-                
+
                 Method m = Observable.class.getMethod("amb", clazz);
-                
+
                 Observable<Integer> obs = (Observable<Integer>)m.invoke(null, (Object[])ps);
-            
+
                 TestSubscriber<Integer> ts = TestSubscriber.create();
-                
+
                 obs.subscribe(ts);
-                
+
                 for (int k = 0; k < i; k++) {
                     assertTrue("@" + i + "/" + k + " has no observers?", ps[k].hasObservers());
                 }
-                
+
                 ps[j].onNext(j);
                 ps[j].onCompleted();
-                
+
                 for (int k = 0; k < i; k++) {
                     assertFalse("@" + i + "/" + k + " has observers?", ps[k].hasObservers());
                 }
-                
+
                 ts.assertValue(j);
                 ts.assertNoErrors();
                 ts.assertCompleted();
             }
         }
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void ambManyError() throws Exception {
@@ -402,38 +402,38 @@ public void ambManyError() throws Exception {
             PublishSubject<Integer>[] ps = new PublishSubject[i];
 
             for (int j = 0; j < i; j++) {
-                
+
                 for (int k = 0; k < i; k++) {
                     ps[k] = PublishSubject.create();
                 }
-                
+
                 Method m = Observable.class.getMethod("amb", clazz);
-                
+
                 Observable<Integer> obs = (Observable<Integer>)m.invoke(null, (Object[])ps);
-            
+
                 TestSubscriber<Integer> ts = TestSubscriber.create();
-                
+
                 obs.subscribe(ts);
-                
+
                 for (int k = 0; k < i; k++) {
                     assertTrue("@" + i + "/" + k + " has no observers?", ps[k].hasObservers());
                 }
-                
+
                 ps[j].onError(new TestException(Integer.toString(j)));
-                
+
                 for (int k = 0; k < i; k++) {
                     assertFalse("@" + i + "/" + k + " has observers?", ps[k].hasObservers());
                 }
-                
+
                 ts.assertNoValues();
                 ts.assertError(TestException.class);
                 ts.assertNotCompleted();
-                
+
                 assertEquals(Integer.toString(j), ts.getOnErrorEvents().get(0).getMessage());
             }
         }
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void ambManyComplete() throws Exception {
@@ -444,29 +444,29 @@ public void ambManyComplete() throws Exception {
             PublishSubject<Integer>[] ps = new PublishSubject[i];
 
             for (int j = 0; j < i; j++) {
-                
+
                 for (int k = 0; k < i; k++) {
                     ps[k] = PublishSubject.create();
                 }
-                
+
                 Method m = Observable.class.getMethod("amb", clazz);
-                
+
                 Observable<Integer> obs = (Observable<Integer>)m.invoke(null, (Object[])ps);
-            
+
                 TestSubscriber<Integer> ts = TestSubscriber.create();
-                
+
                 obs.subscribe(ts);
-                
+
                 for (int k = 0; k < i; k++) {
                     assertTrue("@" + i + "/" + k + " has no observers?", ps[k].hasObservers());
                 }
-                
+
                 ps[j].onCompleted();
-                
+
                 for (int k = 0; k < i; k++) {
                     assertFalse("@" + i + "/" + k + " has observers?", ps[k].hasObservers());
                 }
-                
+
                 ts.assertNoValues();
                 ts.assertNoErrors();
                 ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java b/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java
index f57e493223..859ecd63c9 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -46,7 +46,7 @@ public void testCollectToList() {
             public List<Integer> call() {
                 return new ArrayList<Integer>();
             }
-            
+
         }, new Action2<List<Integer>, Integer>() {
 
             @Override
@@ -54,14 +54,14 @@ public void call(List<Integer> list, Integer v) {
                 list.add(v);
             }
         });
-        
+
         List<Integer> list =  o.toBlocking().last();
 
         assertEquals(3, list.size());
         assertEquals(1, list.get(0).intValue());
         assertEquals(2, list.get(1).intValue());
         assertEquals(3, list.get(2).intValue());
-        
+
         // test multiple subscribe
         List<Integer> list2 =  o.toBlocking().last();
 
@@ -79,7 +79,7 @@ public void testCollectToString() {
             public StringBuilder call() {
                 return new StringBuilder();
             }
-            
+
         }, new Action2<StringBuilder, Integer>() {
 
             @Override
@@ -93,7 +93,7 @@ public void call(StringBuilder sb, Integer v) {
 
         assertEquals("1-2-3", value);
     }
-    
+
     @Test
     public void testFactoryFailureResultsInErrorEmission() {
         TestSubscriber<Object> ts = TestSubscriber.create();
@@ -115,7 +115,7 @@ public void call(List<Integer> list, Integer t) {
         ts.assertError(e);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testCollectorFailureDoesNotResultInTwoErrorEmissions() {
         try {
@@ -248,5 +248,5 @@ public void call(List<Integer> list, Integer t) {
         ts.assertNotCompleted();
         assertFalse(added.get());
     }
-    
+
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java b/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java
index 7eb2f1b11d..1fb0518112 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -773,7 +773,7 @@ public void testBackpressureLoop() {
             testBackpressure();
         }
     }
-    
+
     @Test
     public void testBackpressure() {
         Func2<String, Integer, String> combineLatestFunction = getConcatStringIntegerCombineLatestFunction();
@@ -830,7 +830,7 @@ public Long call(Long t1, Integer t2) {
 
         assertEquals(SIZE, count.get());
     }
-    
+
     @Test(timeout=10000)
     public void testCombineLatestRequestOverflow() throws InterruptedException {
         @SuppressWarnings("unchecked")
@@ -843,7 +843,7 @@ public Integer call(Object... args) {
         //should get at least 4
         final CountDownLatch latch = new CountDownLatch(4);
         o.subscribeOn(Schedulers.computation()).subscribe(new Subscriber<Integer>() {
-            
+
             @Override
             public void onStart() {
                 request(2);
@@ -870,18 +870,18 @@ public void onNext(Integer t) {
     @Test
     public void testCombineMany() {
         int n = RxRingBuffer.SIZE * 3;
-        
+
         List<Observable<Integer>> sources = new ArrayList<Observable<Integer>>();
-        
+
         StringBuilder expected = new StringBuilder(n * 2);
-        
+
         for (int i = 0; i < n; i++) {
             sources.add(Observable.just(i));
             expected.append(i);
         }
-        
+
         TestSubscriber<String> ts = TestSubscriber.create();
-        
+
         Observable.combineLatest(sources, new FuncN<String>() {
             @Override
             public String call(Object... args) {
@@ -892,26 +892,26 @@ public String call(Object... args) {
                 return b.toString();
             }
         }).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertValue(expected.toString());
         ts.assertCompleted();
     }
-    
+
     @Test
     public void testCombineManyNulls() {
         int n = RxRingBuffer.SIZE * 3;
-        
+
         Observable<Integer> source = Observable.just((Integer)null);
-        
+
         List<Observable<Integer>> sources = new ArrayList<Observable<Integer>>();
-        
+
         for (int i = 0; i < n; i++) {
             sources.add(source);
         }
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.combineLatest(sources, new FuncN<Integer>() {
             @Override
             public Integer call(Object... args) {
@@ -924,7 +924,7 @@ public Integer call(Object... args) {
                 return sum;
             }
         }).subscribe(ts);
-        
+
         ts.assertValue(n);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -948,7 +948,7 @@ public void call(Throwable t) {
           .subscribe(ts);
         assertFalse(errorOccurred.get());
     }
-    
+
     private static final FuncN<Integer> THROW_NON_FATAL = new FuncN<Integer>() {
         @Override
         public Integer call(Object... args) {
@@ -956,12 +956,12 @@ public Integer call(Object... args) {
         }
 
     };
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void firstJustError() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.combineLatestDelayError(
                 Arrays.asList(Observable.just(1), Observable.<Integer>error(new TestException())),
                 new FuncN<Integer>() {
@@ -971,7 +971,7 @@ public Integer call(Object... args) {
                     }
                 }
         ).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -981,7 +981,7 @@ public Integer call(Object... args) {
     @Test
     public void secondJustError() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.combineLatestDelayError(
                 Arrays.asList(Observable.<Integer>error(new TestException()), Observable.just(1)),
                 new FuncN<Integer>() {
@@ -991,7 +991,7 @@ public Integer call(Object... args) {
                     }
                 }
         ).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -1001,7 +1001,7 @@ public Integer call(Object... args) {
     @Test
     public void oneErrors() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.combineLatestDelayError(
                 Arrays.asList(Observable.just(10).concatWith(Observable.<Integer>error(new TestException())), Observable.just(1)),
                 new FuncN<Integer>() {
@@ -1011,7 +1011,7 @@ public Integer call(Object... args) {
                     }
                 }
         ).subscribe(ts);
-        
+
         ts.assertValues(11);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -1021,7 +1021,7 @@ public Integer call(Object... args) {
     @Test
     public void twoErrors() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.combineLatestDelayError(
                 Arrays.asList(Observable.just(1), Observable.just(10).concatWith(Observable.<Integer>error(new TestException()))),
                 new FuncN<Integer>() {
@@ -1031,7 +1031,7 @@ public Integer call(Object... args) {
                     }
                 }
         ).subscribe(ts);
-        
+
         ts.assertValues(11);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -1041,9 +1041,9 @@ public Integer call(Object... args) {
     @Test
     public void bothError() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.combineLatestDelayError(
-                Arrays.asList(Observable.just(1).concatWith(Observable.<Integer>error(new TestException())), 
+                Arrays.asList(Observable.just(1).concatWith(Observable.<Integer>error(new TestException())),
                         Observable.just(10).concatWith(Observable.<Integer>error(new TestException()))),
                 new FuncN<Integer>() {
                     @Override
@@ -1052,7 +1052,7 @@ public Integer call(Object... args) {
                     }
                 }
         ).subscribe(ts);
-        
+
         ts.assertValues(11);
         ts.assertError(CompositeException.class);
         ts.assertNotCompleted();
@@ -1062,9 +1062,9 @@ public Integer call(Object... args) {
     @Test
     public void combineLatestIterable() {
         Observable<Integer> source = Observable.just(1);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.combineLatest((Iterable<Observable<Integer>>)Arrays.asList(source, source), new FuncN<Integer>() {
             @Override
             public Integer call(Object... args) {
@@ -1072,7 +1072,7 @@ public Integer call(Object... args) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue(2);
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
index 749fa975ea..c51a7877cd 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeConcatDelayErrorTest.java
@@ -33,20 +33,20 @@ public class OnSubscribeConcatDelayErrorTest {
     @Test
     public void mainCompletes() {
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         source.concatMapDelayError(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
                 return Observable.range(v, 2);
             }
         }).subscribe(ts);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onCompleted();
-        
+
         ts.assertValues(1, 2, 2, 3);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -55,29 +55,29 @@ public Observable<Integer> call(Integer v) {
     @Test
     public void mainErrors() {
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         source.concatMapDelayError(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
                 return Observable.range(v, 2);
             }
         }).subscribe(ts);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onError(new TestException());
-        
+
         ts.assertValues(1, 2, 2, 3);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void innerErrors() {
         final Observable<Integer> inner = Observable.range(1, 2).concatWith(Observable.<Integer>error(new TestException()));
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
 
         Observable.range(1, 3).concatMapDelayError(new Func1<Integer, Observable<Integer>>() {
@@ -86,7 +86,7 @@ public Observable<Integer> call(Integer v) {
                 return inner;
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(1, 2, 1, 2, 1, 2);
         ts.assertError(CompositeException.class);
         ts.assertNotCompleted();
@@ -95,7 +95,7 @@ public Observable<Integer> call(Integer v) {
     @Test
     public void singleInnerErrors() {
         final Observable<Integer> inner = Observable.range(1, 2).concatWith(Observable.<Integer>error(new TestException()));
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
 
         Observable.just(1)
@@ -106,7 +106,7 @@ public Observable<Integer> call(Integer v) {
                 return inner;
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(1, 2);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -124,7 +124,7 @@ public Observable<Integer> call(Integer v) {
                 return null;
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(NullPointerException.class);
         ts.assertNotCompleted();
@@ -142,7 +142,7 @@ public Observable<Integer> call(Integer v) {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -159,7 +159,7 @@ public Observable<Integer> call(Integer v) {
                 return v == 2 ? Observable.<Integer>empty() : Observable.range(1, 2);
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(1, 2, 1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -176,7 +176,7 @@ public Observable<Integer> call(Integer v) {
                 return v == 2 ? Observable.just(3) : Observable.range(1, 2);
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(1, 2, 3, 1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -185,7 +185,7 @@ public Observable<Integer> call(Integer v) {
     @Test
     public void backpressure() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         Observable.range(1, 3).concatMapDelayError(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -196,7 +196,7 @@ public Observable<Integer> call(Integer v) {
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1);
         ts.assertValues(1);
         ts.assertNoErrors();
@@ -208,7 +208,7 @@ public Observable<Integer> call(Integer v) {
         ts.assertNotCompleted();
 
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2, 2, 3, 3, 4);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -217,63 +217,63 @@ public Observable<Integer> call(Integer v) {
     static <T> Observable<T> withError(Observable<T> source) {
         return source.concatWith(Observable.<T>error(new TestException()));
     }
-    
+
 
     @Test
     public void concatDelayErrorObservable() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.concatDelayError(
                 Observable.just(Observable.just(1), Observable.just(2)))
         .subscribe(ts);
-        
+
         ts.assertValues(1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void concatDelayErrorObservableError() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.concatDelayError(
                 withError(Observable.just(withError(Observable.just(1)), withError(Observable.just(2)))))
         .subscribe(ts);
-        
+
         ts.assertValues(1, 2);
         ts.assertError(CompositeException.class);
         ts.assertNotCompleted();
-        
+
         assertEquals(3, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void concatDelayErrorIterable() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.concatDelayError(
                 Arrays.asList(Observable.just(1), Observable.just(2)))
         .subscribe(ts);
-        
+
         ts.assertValues(1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void concatDelayErrorIterableError() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.concatDelayError(
                 Arrays.asList(withError(Observable.just(1)), withError(Observable.just(2))))
         .subscribe(ts);
-        
+
         ts.assertValues(1, 2);
         ts.assertError(CompositeException.class);
         ts.assertNotCompleted();
-        
+
         assertEquals(2, ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions().size());
     }
 
diff --git a/src/test/java/rx/internal/operators/OnSubscribeDeferTest.java b/src/test/java/rx/internal/operators/OnSubscribeDeferTest.java
index dfff5d9381..0cb70da7d3 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeDeferTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeDeferTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -67,19 +67,19 @@ public void testDefer() throws Throwable {
         verify(secondObserver, times(1)).onCompleted();
 
     }
-    
+
     @Test
     public void testDeferFunctionThrows() {
         Func0<Observable<String>> factory = mock(Func0.class);
-        
+
         when(factory.call()).thenThrow(new TestException());
-        
+
         Observable<String> result = Observable.defer(factory);
-        
+
         Observer<String> o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         verify(o).onError(any(TestException.class));
         verify(o, never()).onNext(any(String.class));
         verify(o, never()).onCompleted();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeDelaySubscriptionOtherTest.java b/src/test/java/rx/internal/operators/OnSubscribeDelaySubscriptionOtherTest.java
index d0f2aec125..07b8511a0a 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeDelaySubscriptionOtherTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeDelaySubscriptionOtherTest.java
@@ -30,11 +30,11 @@ public class OnSubscribeDelaySubscriptionOtherTest {
     @Test
     public void testNoPrematureSubscription() {
         PublishSubject<Object> other = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         final AtomicInteger subscribed = new AtomicInteger();
-        
+
         Observable.just(1)
         .doOnSubscribe(new Action0() {
             @Override
@@ -44,30 +44,30 @@ public void call() {
         })
         .delaySubscription(other)
         .subscribe(ts);
-        
+
         ts.assertNotCompleted();
         ts.assertNoErrors();
         ts.assertNoValues();
-        
+
         Assert.assertEquals("Premature subscription", 0, subscribed.get());
-        
+
         other.onNext(1);
-        
+
         Assert.assertEquals("No subscription", 1, subscribed.get());
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void testNoMultipleSubscriptions() {
         PublishSubject<Object> other = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         final AtomicInteger subscribed = new AtomicInteger();
-        
+
         Observable.just(1)
         .doOnSubscribe(new Action0() {
             @Override
@@ -77,31 +77,31 @@ public void call() {
         })
         .delaySubscription(other)
         .subscribe(ts);
-        
+
         ts.assertNotCompleted();
         ts.assertNoErrors();
         ts.assertNoValues();
-        
+
         Assert.assertEquals("Premature subscription", 0, subscribed.get());
-        
+
         other.onNext(1);
         other.onNext(2);
-        
+
         Assert.assertEquals("No subscription", 1, subscribed.get());
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void testCompleteTriggersSubscription() {
         PublishSubject<Object> other = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         final AtomicInteger subscribed = new AtomicInteger();
-        
+
         Observable.just(1)
         .doOnSubscribe(new Action0() {
             @Override
@@ -111,30 +111,30 @@ public void call() {
         })
         .delaySubscription(other)
         .subscribe(ts);
-        
+
         ts.assertNotCompleted();
         ts.assertNoErrors();
         ts.assertNoValues();
-        
+
         Assert.assertEquals("Premature subscription", 0, subscribed.get());
-        
+
         other.onCompleted();
-        
+
         Assert.assertEquals("No subscription", 1, subscribed.get());
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void testNoPrematureSubscriptionToError() {
         PublishSubject<Object> other = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         final AtomicInteger subscribed = new AtomicInteger();
-        
+
         Observable.<Integer>error(new TestException())
         .doOnSubscribe(new Action0() {
             @Override
@@ -144,30 +144,30 @@ public void call() {
         })
         .delaySubscription(other)
         .subscribe(ts);
-        
+
         ts.assertNotCompleted();
         ts.assertNoErrors();
         ts.assertNoValues();
-        
+
         Assert.assertEquals("Premature subscription", 0, subscribed.get());
-        
+
         other.onCompleted();
-        
+
         Assert.assertEquals("No subscription", 1, subscribed.get());
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(TestException.class);
     }
-    
+
     @Test
     public void testNoSubscriptionIfOtherErrors() {
         PublishSubject<Object> other = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         final AtomicInteger subscribed = new AtomicInteger();
-        
+
         Observable.<Integer>error(new TestException())
         .doOnSubscribe(new Action0() {
             @Override
@@ -177,31 +177,31 @@ public void call() {
         })
         .delaySubscription(other)
         .subscribe(ts);
-        
+
         ts.assertNotCompleted();
         ts.assertNoErrors();
         ts.assertNoValues();
-        
+
         Assert.assertEquals("Premature subscription", 0, subscribed.get());
-        
+
         other.onError(new TestException());
-        
+
         Assert.assertEquals("Premature subscription", 0, subscribed.get());
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(TestException.class);
     }
-    
+
     @Test
     public void testBackpressurePassesThrough() {
-        
+
         PublishSubject<Object> other = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create(0L);
-        
+
         final AtomicInteger subscribed = new AtomicInteger();
-        
+
         Observable.just(1, 2, 3, 4, 5)
         .doOnSubscribe(new Action0() {
             @Override
@@ -211,23 +211,23 @@ public void call() {
         })
         .delaySubscription(other)
         .subscribe(ts);
-        
+
         ts.assertNotCompleted();
         ts.assertNoErrors();
         ts.assertNoValues();
-        
+
         Assert.assertEquals("Premature subscription", 0, subscribed.get());
-        
+
         other.onNext(1);
-        
+
         Assert.assertEquals("No subscription", 1, subscribed.get());
 
         Assert.assertFalse("Not unsubscribed from other", other.hasObservers());
-        
+
         ts.assertNotCompleted();
         ts.assertNoErrors();
         ts.assertNoValues();
-        
+
         ts.requestMore(1);
         ts.assertValue(1);
         ts.assertNoErrors();
@@ -243,21 +243,21 @@ public void call() {
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void unsubscriptionPropagatesBeforeSubscribe() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> other = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.delaySubscription(other).subscribe(ts);
-        
+
         Assert.assertFalse("source subscribed?", source.hasObservers());
         Assert.assertTrue("other not subscribed?", other.hasObservers());
-        
+
         ts.unsubscribe();
-        
+
         Assert.assertFalse("source subscribed?", source.hasObservers());
         Assert.assertFalse("other still subscribed?", other.hasObservers());
     }
@@ -266,21 +266,21 @@ public void unsubscriptionPropagatesBeforeSubscribe() {
     public void unsubscriptionPropagatesAfterSubscribe() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> other = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.delaySubscription(other).subscribe(ts);
-        
+
         Assert.assertFalse("source subscribed?", source.hasObservers());
         Assert.assertTrue("other not subscribed?", other.hasObservers());
-        
+
         other.onCompleted();
-        
+
         Assert.assertTrue("source not subscribed?", source.hasObservers());
         Assert.assertFalse("other still subscribed?", other.hasObservers());
-        
+
         ts.unsubscribe();
-        
+
         Assert.assertFalse("source subscribed?", source.hasObservers());
         Assert.assertFalse("other still subscribed?", other.hasObservers());
     }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeDetachTest.java b/src/test/java/rx/internal/operators/OnSubscribeDetachTest.java
index 6257e4d227..6d06019425 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeDetachTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeDetachTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -28,47 +28,47 @@
 public class OnSubscribeDetachTest {
 
     Object o;
-    
+
     @Test
     public void just() throws Exception {
         o = new Object();
-        
+
         WeakReference<Object> wr = new WeakReference<Object>(o);
-        
+
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
-        
+
         Observable.just(o).count().onTerminateDetach().subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertCompleted();
         ts.assertNoErrors();
-        
+
         o = null;
-        
+
         System.gc();
         Thread.sleep(200);
-        
+
         Assert.assertNull("Object retained!", wr.get());
-        
+
     }
-    
+
     @Test
     public void error() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
-        
+
         Observable.error(new TestException()).onTerminateDetach().subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void empty() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
-        
+
         Observable.empty().onTerminateDetach().subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -77,82 +77,82 @@ public void empty() {
     @Test
     public void range() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
-        
+
         Observable.range(1, 1000).onTerminateDetach().subscribe(ts);
-        
+
         ts.assertValueCount(1000);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
 
-    
+
     @Test
     public void backpressured() throws Exception {
         o = new Object();
-        
+
         WeakReference<Object> wr = new WeakReference<Object>(o);
-        
+
         TestSubscriber<Object> ts = new TestSubscriber<Object>(0L);
-        
+
         Observable.just(o).count().onTerminateDetach().subscribe(ts);
 
         ts.assertNoValues();
 
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
         ts.assertCompleted();
         ts.assertNoErrors();
-        
+
         o = null;
-        
+
         System.gc();
         Thread.sleep(200);
-        
+
         Assert.assertNull("Object retained!", wr.get());
     }
 
     @Test
     public void justUnsubscribed() throws Exception {
         o = new Object();
-        
+
         WeakReference<Object> wr = new WeakReference<Object>(o);
-        
+
         TestSubscriber<Object> ts = new TestSubscriber<Object>(0);
-        
+
         Observable.just(o).count().onTerminateDetach().subscribe(ts);
-        
+
         ts.unsubscribe();
         o = null;
-        
+
         System.gc();
         Thread.sleep(200);
-        
+
         Assert.assertNull("Object retained!", wr.get());
-        
+
     }
 
     @Test
     public void deferredUpstreamProducer() {
         final AtomicReference<Subscriber<? super Object>> subscriber = new AtomicReference<Subscriber<? super Object>>();
-        
+
         TestSubscriber<Object> ts = new TestSubscriber<Object>(0);
-        
+
         Observable.create(new OnSubscribe<Object>() {
             @Override
             public void call(Subscriber<? super Object> t) {
                 subscriber.set(t);
             }
         }).onTerminateDetach().subscribe(ts);
-        
+
         ts.requestMore(2);
-        
+
         new OnSubscribeRange(1, 3).call(subscriber.get());
-        
+
         ts.assertValues(1, 2);
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValues(1, 2, 3);
         ts.assertCompleted();
         ts.assertNoErrors();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java b/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
index f9997c3827..397b6496be 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -200,11 +200,11 @@ public void call(Object o) {
             System.out.println("Received exception: " + e);
         }
     }
-    
+
     @Test
     public void testOnErrorThrows() {
         TestSubscriber<Object> ts = TestSubscriber.create();
-        
+
         Observable.error(new TestException())
         .doOnError(new Action1<Throwable>() {
             @Override
@@ -212,19 +212,19 @@ public void call(Throwable e) {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(CompositeException.class);
-        
+
         CompositeException ex = (CompositeException)ts.getOnErrorEvents().get(0);
-        
+
         List<Throwable> exceptions = ex.getExceptions();
         assertEquals(2, exceptions.size());
         assertTrue(exceptions.get(0) instanceof TestException);
         assertTrue(exceptions.get(1) instanceof TestException);
     }
-    
+
     @Test
     public void testIfOnNextActionFailsEmitsErrorAndDoesNotFollowWithCompleted() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -254,7 +254,7 @@ public void call(Integer t) {
         ts.assertError(e1);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testIfOnNextActionFailsEmitsErrorAndDoesNotFollowWithOnNext() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -274,7 +274,7 @@ public void request(long n) {
                     }});
             }})
             .doOnNext(new Action1<Integer>() {
-                
+
                 @Override
                 public void call(Integer t) {
                     throw e1;
@@ -284,7 +284,7 @@ public void call(Integer t) {
         assertEquals(1, ts.getOnErrorEvents().size());
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testIfOnNextActionFailsEmitsErrorAndReportsMoreErrorsToRxJavaHooksNotDownstream() {
         try {
@@ -293,7 +293,7 @@ public void testIfOnNextActionFailsEmitsErrorAndReportsMoreErrorsToRxJavaHooksNo
 
                 @Override
                 public void call(Throwable e) {
-                     list.add(e);  
+                     list.add(e);
                 }});
             TestSubscriber<Integer> ts = TestSubscriber.create();
             final RuntimeException e1 = new RuntimeException();
@@ -328,7 +328,7 @@ public void call(Integer t) {
             RxJavaHooks.reset();
         }
     }
-    
+
     @Test
     public void testIfCompleteActionFailsEmitsError() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -345,7 +345,7 @@ public void call() {
         ts.assertError(e1);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testUnsubscribe() {
         TestSubscriber<Object> ts = TestSubscriber.create(0);
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFilterTest.java b/src/test/java/rx/internal/operators/OnSubscribeFilterTest.java
index 73d91f8f02..f2aa08caf3 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFilterTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFilterTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -117,19 +117,19 @@ public Boolean call(Integer t1) {
 
         final CountDownLatch latch = new CountDownLatch(1);
         final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0L) {
-            
+
             @Override
             public void onCompleted() {
                 System.out.println("onCompleted");
                 latch.countDown();
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 e.printStackTrace();
                 latch.countDown();
             }
-            
+
             @Override
             public void onNext(Integer t) {
                 System.out.println("Received: " + t);
@@ -145,7 +145,7 @@ public void onNext(Integer t) {
         // this will wait forever unless OperatorTake handles the request(n) on filtered items
         latch.await();
     }
-    
+
     @Test
     public void testFatalError() {
         try {
@@ -173,37 +173,37 @@ public void call(Integer t) {
 
     @Test
     public void functionCrashUnsubscribes() {
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         ps.filter(new Func1<Integer, Boolean>() {
             @Override
-            public Boolean call(Integer v) { 
-                throw new TestException(); 
+            public Boolean call(Integer v) {
+                throw new TestException();
             }
         }).unsafeSubscribe(ts);
-        
+
         Assert.assertTrue("Not subscribed?", ps.hasObservers());
-        
+
         ps.onNext(1);
-        
+
         Assert.assertFalse("Subscribed?", ps.hasObservers());
-        
+
         ts.assertError(TestException.class);
     }
 
     @Test
     public void doesntRequestOnItsOwn() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0L);
-        
+
         Observable.range(1, 10).filter(UtilityFunctions.alwaysTrue()).unsafeSubscribe(ts);
-        
+
         ts.assertNoValues();
-        
+
         ts.requestMore(10);
-        
+
         ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java b/src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java
index af4f989ce6..66347a43c4 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFlattenIterableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -28,21 +28,21 @@
 import rx.subjects.PublishSubject;
 
 public class OnSubscribeFlattenIterableTest {
-    
+
     final Func1<Integer, Iterable<Integer>> mapper = new Func1<Integer, Iterable<Integer>>() {
         @Override
         public Iterable<Integer> call(Integer v) {
             return Arrays.asList(v, v + 1);
         }
     };
-    
+
     @Test
     public void normal() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.range(1, 5).concatMapIterable(mapper)
         .subscribe(ts);
-        
+
         ts.assertValues(1, 2, 2, 3, 3, 4, 4, 5, 5, 6);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -51,40 +51,40 @@ public void normal() {
     @Test
     public void normalViaFlatMap() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.range(1, 5).flatMapIterable(mapper)
         .subscribe(ts);
-        
+
         ts.assertValues(1, 2, 2, 3, 3, 4, 4, 5, 5, 6);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void normalBackpressured() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
-        
+
         Observable.range(1, 5).concatMapIterable(mapper)
         .subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2, 2);
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(7);
-        
+
         ts.assertValues(1, 2, 2, 3, 3, 4, 4, 5, 5, 6);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -93,9 +93,9 @@ public void normalBackpressured() {
     @Test
     public void longRunning() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         int n = 1000 * 1000;
-        
+
         Observable.range(1, n).concatMapIterable(mapper)
         .subscribe(ts);
 
@@ -107,9 +107,9 @@ public void longRunning() {
     @Test
     public void asIntermediate() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         int n = 1000 * 1000;
-        
+
         Observable.range(1, n).concatMapIterable(mapper).concatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
@@ -126,10 +126,10 @@ public Observable<Integer> call(Integer v) {
     @Test
     public void just() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.just(1).concatMapIterable(mapper)
         .subscribe(ts);
-        
+
         ts.assertValues(1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -138,10 +138,10 @@ public void just() {
     @Test
     public void justHidden() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.just(1).asObservable().concatMapIterable(mapper)
         .subscribe(ts);
-        
+
         ts.assertValues(1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -150,23 +150,23 @@ public void justHidden() {
     @Test
     public void empty() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.<Integer>empty().concatMapIterable(mapper)
         .subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void error() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.<Integer>just(1).concatWith(Observable.<Integer>error(new TestException()))
         .concatMapIterable(mapper)
         .subscribe(ts);
-        
+
         ts.assertValues(1, 2);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -175,7 +175,7 @@ public void error() {
     @Test
     public void iteratorHasNextThrowsImmediately() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         final Iterable<Integer> it = new Iterable<Integer>() {
             @Override
             public Iterator<Integer> iterator() {
@@ -184,12 +184,12 @@ public Iterator<Integer> iterator() {
                     public boolean hasNext() {
                         throw new TestException();
                     }
-                    
+
                     @Override
                     public Integer next() {
                         return 1;
                     }
-                    
+
                     @Override
                     public void remove() {
                         throw new UnsupportedOperationException();
@@ -197,7 +197,7 @@ public void remove() {
                 };
             }
         };
-        
+
         Observable.range(1, 2)
         .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
             @Override
@@ -206,7 +206,7 @@ public Iterable<Integer> call(Integer v) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -215,7 +215,7 @@ public Iterable<Integer> call(Integer v) {
     @Test
     public void iteratorHasNextThrowsImmediatelyJust() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         final Iterable<Integer> it = new Iterable<Integer>() {
             @Override
             public Iterator<Integer> iterator() {
@@ -224,12 +224,12 @@ public Iterator<Integer> iterator() {
                     public boolean hasNext() {
                         throw new TestException();
                     }
-                    
+
                     @Override
                     public Integer next() {
                         return 1;
                     }
-                    
+
                     @Override
                     public void remove() {
                         throw new UnsupportedOperationException();
@@ -237,7 +237,7 @@ public void remove() {
                 };
             }
         };
-        
+
         Observable.just(1)
         .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
             @Override
@@ -246,7 +246,7 @@ public Iterable<Integer> call(Integer v) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -255,7 +255,7 @@ public Iterable<Integer> call(Integer v) {
     @Test
     public void iteratorHasNextThrowsSecondCall() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         final Iterable<Integer> it = new Iterable<Integer>() {
             @Override
             public Iterator<Integer> iterator() {
@@ -268,12 +268,12 @@ public boolean hasNext() {
                         }
                         return true;
                     }
-                    
+
                     @Override
                     public Integer next() {
                         return 1;
                     }
-                    
+
                     @Override
                     public void remove() {
                         throw new UnsupportedOperationException();
@@ -281,7 +281,7 @@ public void remove() {
                 };
             }
         };
-        
+
         Observable.range(1, 2)
         .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
             @Override
@@ -290,7 +290,7 @@ public Iterable<Integer> call(Integer v) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -299,7 +299,7 @@ public Iterable<Integer> call(Integer v) {
     @Test
     public void iteratorNextThrows() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         final Iterable<Integer> it = new Iterable<Integer>() {
             @Override
             public Iterator<Integer> iterator() {
@@ -308,12 +308,12 @@ public Iterator<Integer> iterator() {
                     public boolean hasNext() {
                         return true;
                     }
-                    
+
                     @Override
                     public Integer next() {
                         throw new TestException();
                     }
-                    
+
                     @Override
                     public void remove() {
                         throw new UnsupportedOperationException();
@@ -321,7 +321,7 @@ public void remove() {
                 };
             }
         };
-        
+
         Observable.range(1, 2)
         .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
             @Override
@@ -330,7 +330,7 @@ public Iterable<Integer> call(Integer v) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -339,7 +339,7 @@ public Iterable<Integer> call(Integer v) {
     @Test
     public void iteratorNextThrowsAndUnsubscribes() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         final Iterable<Integer> it = new Iterable<Integer>() {
             @Override
             public Iterator<Integer> iterator() {
@@ -348,12 +348,12 @@ public Iterator<Integer> iterator() {
                     public boolean hasNext() {
                         return true;
                     }
-                    
+
                     @Override
                     public Integer next() {
                         throw new TestException();
                     }
-                    
+
                     @Override
                     public void remove() {
                         throw new UnsupportedOperationException();
@@ -361,9 +361,9 @@ public void remove() {
                 };
             }
         };
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps
         .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
             @Override
@@ -372,20 +372,20 @@ public Iterable<Integer> call(Integer v) {
             }
         })
         .unsafeSubscribe(ts);
-        
+
         ps.onNext(1);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
-        
+
         Assert.assertFalse("PublishSubject has Observers?!", ps.hasObservers());
     }
 
     @Test
     public void mixture() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.range(0, 1000)
         .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
             @Override
@@ -394,16 +394,16 @@ public Iterable<Integer> call(Integer v) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValueCount(500);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void emptyInnerThenSingleBackpressured() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(1);
-        
+
         Observable.range(1, 2)
         .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
             @Override
@@ -412,16 +412,16 @@ public Iterable<Integer> call(Integer v) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void manyEmptyInnerThenSingleBackpressured() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(1);
-        
+
         Observable.range(1, 1000)
         .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
             @Override
@@ -430,18 +430,18 @@ public Iterable<Integer> call(Integer v) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void hasNextIsNotCalledAfterChildUnsubscribedOnNext() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         final AtomicInteger counter = new AtomicInteger();
-        
+
         final Iterable<Integer> it = new Iterable<Integer>() {
             @Override
             public Iterator<Integer> iterator() {
@@ -451,12 +451,12 @@ public boolean hasNext() {
                         counter.getAndIncrement();
                         return true;
                     }
-                    
+
                     @Override
                     public Integer next() {
                         return 1;
                     }
-                    
+
                     @Override
                     public void remove() {
                         throw new UnsupportedOperationException();
@@ -464,9 +464,9 @@ public void remove() {
                 };
             }
         };
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps
         .concatMapIterable(new Func1<Integer, Iterable<Integer>>() {
             @Override
@@ -476,33 +476,33 @@ public Iterable<Integer> call(Integer v) {
         })
         .take(1)
         .unsafeSubscribe(ts);
-        
+
         ps.onNext(1);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         Assert.assertFalse("PublishSubject has Observers?!", ps.hasObservers());
         Assert.assertEquals(1, counter.get());
     }
-    
+
     @Test
     public void normalPrefetchViaFlatMap() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.range(1, 5).flatMapIterable(mapper, 2)
         .subscribe(ts);
-        
+
         ts.assertValues(1, 2, 2, 3, 3, 4, 4, 5, 5, 6);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void withResultSelectorMaxConcurrent() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 5).flatMapIterable(new Func1<Integer, Iterable<Integer>>() {
             @Override
             public Iterable<Integer> call(Integer v) {
@@ -516,7 +516,7 @@ public Integer call(Integer a, Integer b) {
         }, 2)
         .subscribe(ts)
         ;
-        
+
         ts.assertValues(11, 21, 31, 41, 51);
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java
index 1b427bbdda..cd117169d2 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -23,7 +23,7 @@
 import rx.observers.TestSubscriber;
 
 public class OnSubscribeFromArrayTest {
-    
+
     Observable<Integer> create(int n) {
         Integer[] array = new Integer[n];
         for (int i = 0; i < n; i++) {
@@ -34,9 +34,9 @@ Observable<Integer> create(int n) {
     @Test
     public void simple() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         create(1000).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertValueCount(1000);
         ts.assertCompleted();
@@ -45,21 +45,21 @@ public void simple() {
     @Test
     public void backpressure() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         create(1000).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertNoValues();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(10);
-        
+
         ts.assertNoErrors();
         ts.assertValueCount(10);
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1000);
-        
+
         ts.assertNoErrors();
         ts.assertValueCount(1000);
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
index 2579bc9528..61cb9d75ab 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -38,30 +38,30 @@ public class OnSubscribeFromEmitterTest {
     PublishAsyncEmitterNoCancel sourceNoCancel;
 
     TestSubscriber<Integer> ts;
-    
+
     @Before
     public void before() {
         source = new PublishAsyncEmitter();
         sourceNoCancel = new PublishAsyncEmitterNoCancel();
         ts = TestSubscriber.create(0L);
     }
-    
+
     @Test
     public void normalBuffered() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
-        
+
         Assert.assertEquals(0, source.requested());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValues(1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -70,14 +70,14 @@ public void normalBuffered() {
     @Test
     public void normalDrop() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
-        
+
         source.onNext(1);
 
         ts.requestMore(1);
 
         source.onNext(2);
         source.onCompleted();
-        
+
         ts.assertValues(2);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -86,7 +86,7 @@ public void normalDrop() {
     @Test
     public void normalLatest() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-        
+
         source.onNext(1);
 
         source.onNext(2);
@@ -102,7 +102,7 @@ public void normalLatest() {
     @Test
     public void normalNone() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onCompleted();
@@ -116,7 +116,7 @@ public void normalNone() {
     public void normalNoneRequested() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
         ts.requestMore(2);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onCompleted();
@@ -130,7 +130,7 @@ public void normalNoneRequested() {
     @Test
     public void normalError() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onCompleted();
@@ -138,10 +138,10 @@ public void normalError() {
         ts.assertNoValues();
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
-        
+
         Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
     }
-    
+
     @Test
     public void overflowErrorIsNotFollowedByAnotherErrorDueToOnNextFromUpstream() {
         Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
@@ -153,14 +153,14 @@ public void call(AsyncEmitter<Integer> emitter) {
                 emitter.onNext(2);
             }};
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
-        
+
         Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
     }
-    
+
     @Test
     public void overflowErrorIsNotFollowedByAnotherCompletedDueToCompletedFromUpstream() {
         Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
@@ -172,14 +172,14 @@ public void call(AsyncEmitter<Integer> emitter) {
                 emitter.onCompleted();
             }};
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
-        
+
         Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
     }
-    
+
     @Test
     public void overflowErrorIsNotFollowedByAnotherErrorDueToOnErrorFromUpstreamAndSecondErrorIsReportedToHook() {
         try {
@@ -191,7 +191,7 @@ public void call(Throwable t) {
                 }});
             final RuntimeException e = new RuntimeException();
             Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
-    
+
                 @Override
                 public void call(AsyncEmitter<Integer> emitter) {
                     emitter.onNext(1);
@@ -199,11 +199,11 @@ public void call(AsyncEmitter<Integer> emitter) {
                     emitter.onError(e);
                 }};
             Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
-            
+
             ts.assertNoValues();
             ts.assertError(MissingBackpressureException.class);
             ts.assertNotCompleted();
-            
+
             Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
             assertEquals(Arrays.asList(e), list);
         } finally {
@@ -214,17 +214,17 @@ public void call(AsyncEmitter<Integer> emitter) {
     @Test
     public void errorBuffered() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValues(1, 2);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -233,28 +233,28 @@ public void errorBuffered() {
     @Test
     public void errorLatest() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValues(2);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void errorNone() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValues(1, 2);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -264,13 +264,13 @@ public void errorNone() {
     public void unsubscribedBuffer() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.unsubscribe();
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -280,13 +280,13 @@ public void unsubscribedBuffer() {
     public void unsubscribedLatest() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
         ts.unsubscribe();
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -296,13 +296,13 @@ public void unsubscribedLatest() {
     public void unsubscribedError() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
         ts.unsubscribe();
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -312,13 +312,13 @@ public void unsubscribedError() {
     public void unsubscribedDrop() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
         ts.unsubscribe();
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -328,13 +328,13 @@ public void unsubscribedDrop() {
     public void unsubscribedNone() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
         ts.unsubscribe();
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -344,13 +344,13 @@ public void unsubscribedNone() {
     public void unsubscribedNoCancelBuffer() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.unsubscribe();
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
         sourceNoCancel.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -360,13 +360,13 @@ public void unsubscribedNoCancelBuffer() {
     public void unsubscribedNoCancelLatest() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
         ts.unsubscribe();
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
         sourceNoCancel.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -376,13 +376,13 @@ public void unsubscribedNoCancelLatest() {
     public void unsubscribedNoCancelError() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
         ts.unsubscribe();
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
         sourceNoCancel.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -392,13 +392,13 @@ public void unsubscribedNoCancelError() {
     public void unsubscribedNoCancelDrop() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
         ts.unsubscribe();
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
         sourceNoCancel.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -408,13 +408,13 @@ public void unsubscribedNoCancelDrop() {
     public void unsubscribedNoCancelNone() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
         ts.unsubscribe();
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
         sourceNoCancel.onError(new TestException());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -423,13 +423,13 @@ public void unsubscribedNoCancelNone() {
     @Test
     public void deferredRequest() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -438,13 +438,13 @@ public void deferredRequest() {
     @Test
     public void take() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -454,11 +454,11 @@ public void take() {
     public void takeOne() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
         ts.requestMore(2);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onCompleted();
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -468,11 +468,11 @@ public void takeOne() {
     public void requestExact() {
         Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.requestMore(2);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onCompleted();
-        
+
         ts.assertValues(1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -481,13 +481,13 @@ public void requestExact() {
     @Test
     public void takeNoCancel() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
         sourceNoCancel.onCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -497,11 +497,11 @@ public void takeNoCancel() {
     public void takeOneNoCancel() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
         ts.requestMore(2);
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
         sourceNoCancel.onCompleted();
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -511,13 +511,13 @@ public void takeOneNoCancel() {
     public void unsubscribeNoCancel() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.requestMore(2);
-        
+
         sourceNoCancel.onNext(1);
 
         ts.unsubscribe();
-        
+
         sourceNoCancel.onNext(2);
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -533,11 +533,11 @@ public void onNext(Integer t) {
                 unsubscribe();
             }
         };
-        
+
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
-        
+
         sourceNoCancel.onNext(1);
-        
+
         ts1.assertValues(1);
         ts1.assertNoErrors();
         ts1.assertNotCompleted();
@@ -546,12 +546,12 @@ public void onNext(Integer t) {
     @Test
     public void completeInline() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -560,12 +560,12 @@ public void completeInline() {
     @Test
     public void errorInline() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onError(new TestException());
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -580,12 +580,12 @@ public void onNext(Integer t) {
                 requestMore(1);
             }
         };
-        
+
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
-        
+
         ts1.assertValues(1, 2);
         ts1.assertNoErrors();
         ts1.assertNotCompleted();
@@ -600,11 +600,11 @@ public void onNext(Integer t) {
                 unsubscribe();
             }
         };
-        
+
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
-        
+
         sourceNoCancel.onNext(1);
-        
+
         ts1.assertValues(1);
         ts1.assertNoErrors();
         ts1.assertNotCompleted();
@@ -619,11 +619,11 @@ public void onNext(Integer t) {
                 unsubscribe();
             }
         };
-        
+
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
-        
+
         sourceNoCancel.onNext(1);
-        
+
         ts1.assertValues(1);
         ts1.assertNoErrors();
         ts1.assertNotCompleted();
@@ -632,12 +632,12 @@ public void onNext(Integer t) {
     @Test
     public void completeInlineLatest() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -646,12 +646,12 @@ public void completeInlineLatest() {
     @Test
     public void completeInlineExactLatest() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -660,12 +660,12 @@ public void completeInlineExactLatest() {
     @Test
     public void errorInlineLatest() {
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onError(new TestException());
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -680,36 +680,36 @@ public void onNext(Integer t) {
                 requestMore(1);
             }
         };
-        
+
         Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
-        
+
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
-        
+
         ts1.assertValues(1, 2);
         ts1.assertNoErrors();
         ts1.assertNotCompleted();
     }
-    
+
     static final class PublishAsyncEmitter implements Action1<AsyncEmitter<Integer>>, Observer<Integer> {
-        
+
         final PublishSubject<Integer> subject;
-        
+
         AsyncEmitter<Integer> current;
-        
+
         public PublishAsyncEmitter() {
             this.subject = PublishSubject.create();
         }
-        
+
         long requested() {
             return current.requested();
         }
-        
+
         @Override
         public void call(final AsyncEmitter<Integer> t) {
 
             this.current = t;
-            
+
             final Subscription s = subject.subscribe(new Observer<Integer>() {
 
                 @Override
@@ -726,9 +726,9 @@ public void onError(Throwable e) {
                 public void onNext(Integer v) {
                     t.onNext(v);
                 }
-                
+
             });
-            
+
             t.setCancellation(new AsyncEmitter.Cancellable() {
                 @Override
                 public void cancel() throws Exception {
@@ -736,31 +736,31 @@ public void cancel() throws Exception {
                 }
             });;
         }
-        
+
         @Override
         public void onNext(Integer t) {
             subject.onNext(t);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             subject.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             subject.onCompleted();
         }
     }
-    
+
     static final class PublishAsyncEmitterNoCancel implements Action1<AsyncEmitter<Integer>>, Observer<Integer> {
-        
+
         final PublishSubject<Integer> subject;
-        
+
         public PublishAsyncEmitterNoCancel() {
             this.subject = PublishSubject.create();
         }
-        
+
         @Override
         public void call(final AsyncEmitter<Integer> t) {
 
@@ -780,20 +780,20 @@ public void onError(Throwable e) {
                 public void onNext(Integer v) {
                     t.onNext(v);
                 }
-                
+
             });
         }
-        
+
         @Override
         public void onNext(Integer t) {
             subject.onNext(t);
         }
-        
+
         @Override
         public void onError(Throwable e) {
             subject.onError(e);
         }
-        
+
         @Override
         public void onCompleted() {
             subject.onCompleted();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java
index 00956b9cae..4feca72cdd 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -40,7 +40,7 @@ public class OnSubscribeFromIterableTest {
     public void testNull() {
         Observable.create(new OnSubscribeFromIterable<String>(null));
     }
-    
+
     @Test
     public void testListIterable() {
         Observable<String> observable = Observable.create(new OnSubscribeFromIterable<String>(Arrays.<String> asList("one", "two", "three")));
@@ -158,14 +158,14 @@ public void testSubscribeMultipleTimes() {
         o.call(ts);
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3));
     }
-    
+
     @Test
     public void testFromIterableRequestOverflow() throws InterruptedException {
         Observable<Integer> o = Observable.from(Arrays.asList(1,2,3,4));
         final int expectedCount = 4;
         final CountDownLatch latch = new CountDownLatch(expectedCount);
         o.subscribeOn(Schedulers.computation()).subscribe(new Subscriber<Integer>() {
-            
+
             @Override
             public void onStart() {
                 request(2);
@@ -198,7 +198,7 @@ public void testFromEmptyIterableWhenZeroRequestedShouldStillEmitOnCompletedEage
             public void onStart() {
                 request(0);
             }
-            
+
             @Override
             public void onCompleted() {
                 completed.set(true);
@@ -206,16 +206,16 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                
+
             }
 
             @Override
             public void onNext(Object t) {
-                
+
             }});
         assertTrue(completed.get());
     }
-    
+
     @Test
     public void testDoesNotCallIteratorHasNextMoreThanRequiredWithBackpressure() {
         final AtomicBoolean called = new AtomicBoolean(false);
@@ -226,7 +226,7 @@ public Iterator<Integer> iterator() {
                 return new Iterator<Integer>() {
 
                     int count = 1;
-                    
+
                     @Override
                     public void remove() {
                         // ignore
@@ -315,11 +315,11 @@ public Iterator<Integer> iterator() {
                 throw new TestException("Forced failure");
             }
         };
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.from(it).unsafeSubscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -335,12 +335,12 @@ public Iterator<Integer> iterator() {
                     public boolean hasNext() {
                         throw new TestException("Forced failure");
                     }
-                    
+
                     @Override
                     public Integer next() {
                         return null;
                     }
-                    
+
                     @Override
                     public void remove() {
                         // ignored
@@ -348,11 +348,11 @@ public void remove() {
                 };
             }
         };
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.from(it).unsafeSubscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -372,12 +372,12 @@ public boolean hasNext() {
                         }
                         return true;
                     }
-                    
+
                     @Override
                     public Integer next() {
                         return 1;
                     }
-                    
+
                     @Override
                     public void remove() {
                         // ignored
@@ -385,11 +385,11 @@ public void remove() {
                 };
             }
         };
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.from(it).unsafeSubscribe(ts);
-        
+
         ts.assertValues(1);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -409,12 +409,12 @@ public boolean hasNext() {
                         }
                         return true;
                     }
-                    
+
                     @Override
                     public Integer next() {
                         return 1;
                     }
-                    
+
                     @Override
                     public void remove() {
                         // ignored
@@ -422,16 +422,16 @@ public void remove() {
                 };
             }
         };
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(5);
-        
+
         Observable.from(it).unsafeSubscribe(ts);
-        
+
         ts.assertValues(1);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void nextThrowsFastpath() {
         Iterable<Integer> it = new Iterable<Integer>() {
@@ -442,12 +442,12 @@ public Iterator<Integer> iterator() {
                     public boolean hasNext() {
                         return true;
                     }
-                    
+
                     @Override
                     public Integer next() {
                         throw new TestException("Forced failure");
                     }
-                    
+
                     @Override
                     public void remove() {
                         // ignored
@@ -455,11 +455,11 @@ public void remove() {
                 };
             }
         };
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.from(it).unsafeSubscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -475,12 +475,12 @@ public Iterator<Integer> iterator() {
                     public boolean hasNext() {
                         return true;
                     }
-                    
+
                     @Override
                     public Integer next() {
                         throw new TestException("Forced failure");
                     }
-                    
+
                     @Override
                     public void remove() {
                         // ignored
@@ -488,11 +488,11 @@ public void remove() {
                 };
             }
         };
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(5);
-        
+
         Observable.from(it).unsafeSubscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -508,12 +508,12 @@ public Iterator<Integer> iterator() {
                     public boolean hasNext() {
                         return false;
                     }
-                    
+
                     @Override
                     public Integer next() {
                         throw new NoSuchElementException();
                     }
-                    
+
                     @Override
                     public void remove() {
                         // ignored
@@ -521,15 +521,15 @@ public void remove() {
                 };
             }
         };
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(5);
         ts.unsubscribe();
-        
+
         Observable.from(it).unsafeSubscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
     }
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeGroupJoinTest.java b/src/test/java/rx/internal/operators/OnSubscribeGroupJoinTest.java
index 9a1d7aa9ef..f053929c47 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeGroupJoinTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeGroupJoinTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/OnSubscribeJoinTest.java b/src/test/java/rx/internal/operators/OnSubscribeJoinTest.java
index 76f12728f9..6f5cc80ae2 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeJoinTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeJoinTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/OnSubscribeMapTest.java b/src/test/java/rx/internal/operators/OnSubscribeMapTest.java
index 821ed4f09e..4cc589a7cc 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeMapTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeMapTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -332,27 +332,27 @@ public void call(String s) {
             }
         });
     }
-    
+
     @Test
     public void functionCrashUnsubscribes() {
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         ps.map(new Func1<Integer, Integer>() {
             @Override
-            public Integer call(Integer v) { 
-                throw new TestException(); 
+            public Integer call(Integer v) {
+                throw new TestException();
             }
         }).unsafeSubscribe(ts);
-        
+
         Assert.assertTrue("Not subscribed?", ps.hasObservers());
-        
+
         ps.onNext(1);
-        
+
         Assert.assertFalse("Subscribed?", ps.hasObservers());
-        
+
         ts.assertError(TestException.class);
     }
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeRangeTest.java b/src/test/java/rx/internal/operators/OnSubscribeRangeTest.java
index 7838f30474..291d351943 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeRangeTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeRangeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -127,11 +127,11 @@ public void testNoBackpressure() {
     }
     void testWithBackpressureOneByOne(int start) {
         Observable<Integer> source = Observable.range(start, 100);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
         ts.requestMore(1);
         source.subscribe(ts);
-        
+
         List<Integer> list = new ArrayList<Integer>(100);
         for (int i = 0; i < 100; i++) {
             list.add(i + start);
@@ -142,11 +142,11 @@ void testWithBackpressureOneByOne(int start) {
     }
     void testWithBackpressureAllAtOnce(int start) {
         Observable<Integer> source = Observable.range(start, 100);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
         ts.requestMore(100);
         source.subscribe(ts);
-        
+
         List<Integer> list = new ArrayList<Integer>(100);
         for (int i = 0; i < 100; i++) {
             list.add(i + start);
@@ -169,22 +169,22 @@ public void testWithBackpressureAllAtOnce() {
     @Test
     public void testWithBackpressureRequestWayMore() {
         Observable<Integer> source = Observable.range(50, 100);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
         ts.requestMore(150);
         source.subscribe(ts);
-        
+
         List<Integer> list = new ArrayList<Integer>(100);
         for (int i = 0; i < 100; i++) {
             list.add(i + 50);
         }
-        
+
         ts.requestMore(50); // and then some
-        
+
         ts.assertReceivedOnNext(list);
         ts.assertTerminalEvent();
     }
-    
+
     @Test
     public void testRequestOverflow() {
         final AtomicInteger count = new AtomicInteger();
@@ -195,7 +195,7 @@ public void testRequestOverflow() {
             public void onStart() {
                 request(2);
             }
-            
+
             @Override
             public void onCompleted() {
                 //do nothing
@@ -213,7 +213,7 @@ public void onNext(Integer t) {
             }});
         assertEquals(n, count.get());
     }
-    
+
     @Test
     public void testEmptyRangeSendsOnCompleteEagerlyWithRequestZero() {
         final AtomicBoolean completed = new AtomicBoolean(false);
@@ -223,7 +223,7 @@ public void testEmptyRangeSendsOnCompleteEagerlyWithRequestZero() {
             public void onStart() {
                 request(0);
             }
-            
+
             @Override
             public void onCompleted() {
                 completed.set(true);
@@ -231,21 +231,21 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                
+
             }
 
             @Override
             public void onNext(Integer t) {
-                
+
             }});
         assertTrue(completed.get());
     }
-    
+
     @Test(timeout = 1000)
     public void testNearMaxValueWithoutBackpressure() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
         Observable.range(Integer.MAX_VALUE - 1, 2).subscribe(ts);
-        
+
         ts.assertCompleted();
         ts.assertNoErrors();
         ts.assertValues(Integer.MAX_VALUE - 1, Integer.MAX_VALUE);
@@ -254,12 +254,12 @@ public void testNearMaxValueWithoutBackpressure() {
     public void testNearMaxValueWithBackpressure() {
         TestSubscriber<Integer> ts = TestSubscriber.create(3);
         Observable.range(Integer.MAX_VALUE - 1, 2).subscribe(ts);
-        
+
         ts.assertCompleted();
         ts.assertNoErrors();
         ts.assertValues(Integer.MAX_VALUE - 1, Integer.MAX_VALUE);
     }
-    
+
     @Test
     public void negativeCount() {
         try {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java b/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
index eddc465189..9ae07b6112 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -141,7 +141,7 @@ public void testBackpressureWithInitialValue() throws InterruptedException {
         Integer r = reduced.toBlocking().first();
         assertEquals(21, r.intValue());
     }
-    
+
     @Test
     public void testNoInitialValueDoesNotEmitMultipleTerminalEvents() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -172,7 +172,7 @@ public Integer call(Integer a, Integer b) {
         ts.assertError(RuntimeException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testNoInitialValueUpstreamEmitsMoreOnNextDespiteUnsubscription() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -196,7 +196,7 @@ public void request(long n) {
         })
         .reduce(new Func2<Integer, Integer, Integer>() {
             boolean once = true;
-            
+
             @Override
             public Integer call(Integer a, Integer b) {
                 if (once) {
@@ -211,7 +211,7 @@ public Integer call(Integer a, Integer b) {
         ts.assertError(RuntimeException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testNoInitialValueDoesNotEmitMultipleErrorEventsAndReportsSecondErrorToHooks() {
         try {
@@ -259,7 +259,7 @@ public Integer call(Integer a, Integer b) {
         }
     }
 
-    
+
     @Test
     public void testNoInitialValueEmitsNoSuchElementExceptionIfEmptyStream() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java b/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java
index ab076ce411..e0761a576a 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -276,7 +276,7 @@ public void testConnectUnsubscribeRaceConditionLoop() throws InterruptedExceptio
             testConnectUnsubscribeRaceCondition();
         }
     }
-    
+
     @Test
     public void testConnectUnsubscribeRaceCondition() throws InterruptedException {
         final AtomicInteger subUnsubCount = new AtomicInteger();
@@ -302,7 +302,7 @@ public void call() {
                 });
 
         TestSubscriber<Long> s = new TestSubscriber<Long>();
-        
+
         o.publish().refCount().subscribeOn(Schedulers.computation()).subscribe(s);
         System.out.println("send unsubscribe");
         // now immediately unsubscribe while subscribeOn is racing to subscribe
@@ -528,10 +528,10 @@ public Integer call(Integer t1, Integer t2) {
 
     @Test(timeout = 10000)
     public void testUpstreamErrorAllowsRetry() throws InterruptedException {
-        
+
         final AtomicReference<Throwable> err1 = new AtomicReference<Throwable>();
         final AtomicReference<Throwable> err2 = new AtomicReference<Throwable>();
-        
+
         final AtomicInteger intervalSubscribed = new AtomicInteger();
         Observable<String> interval =
                 Observable.interval(200,TimeUnit.MILLISECONDS)
@@ -602,12 +602,12 @@ public void call(Throwable t) {
                         err2.set(t);
                     }
                 });
-        
+
         Thread.sleep(1300);
-        
+
         System.out.println(intervalSubscribed.get());
         assertEquals(6, intervalSubscribed.get());
-        
+
         assertNotNull("First subscriber didn't get the error", err1);
         assertNotNull("Second subscriber didn't get the error", err2);
     }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeSingleTest.java b/src/test/java/rx/internal/operators/OnSubscribeSingleTest.java
index 8b3dbf910e..2f7687da8d 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeSingleTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeSingleTest.java
@@ -75,7 +75,7 @@ public void testRepeatObservableThrowsError() {
 
         subscriber.assertError(IllegalArgumentException.class);
     }
-    
+
     @Test
     public void testShouldUseUnsafeSubscribeInternallyNotSubscribe() {
         TestSubscriber<String> subscriber = TestSubscriber.create();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeTimerTest.java b/src/test/java/rx/internal/operators/OnSubscribeTimerTest.java
index d520d15c75..98e7a05e90 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeTimerTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeTimerTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -234,7 +234,7 @@ public void testWithMultipleStaggeredSubscribersAndPublish() {
     @Test
     public void testOnceObserverThrows() {
         Observable<Long> source = Observable.timer(100, TimeUnit.MILLISECONDS, scheduler);
-        
+
         source.subscribe(new Subscriber<Long>() {
 
             @Override
@@ -252,9 +252,9 @@ public void onCompleted() {
                 observer.onCompleted();
             }
         });
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         verify(observer).onError(any(TestException.class));
         verify(observer, never()).onNext(anyLong());
         verify(observer, never()).onCompleted();
@@ -262,9 +262,9 @@ public void onCompleted() {
     @Test
     public void testPeriodicObserverThrows() {
         Observable<Long> source = Observable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler);
-        
+
         InOrder inOrder = inOrder(observer);
-        
+
         source.subscribe(new Subscriber<Long>() {
 
             @Override
@@ -285,9 +285,9 @@ public void onCompleted() {
                 observer.onCompleted();
             }
         });
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         inOrder.verify(observer).onNext(0L);
         inOrder.verify(observer).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
@@ -324,10 +324,10 @@ public void timerInterval() {
     public void timerIntervalDefaultScheduler() {
         @SuppressWarnings("deprecation")
         Observable<Long> source = Observable.timer(1, 1, TimeUnit.MILLISECONDS).take(100);
-        
+
         TestSubscriber<Long> ts = TestSubscriber.create();
         source.subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValueCount(100);
         ts.assertNoErrors();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeToMapTest.java b/src/test/java/rx/internal/operators/OnSubscribeToMapTest.java
index 0cdba86951..1ed6a542a8 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeToMapTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToMapTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -237,23 +237,23 @@ public Integer call(String t1) {
     @Test
     public void testKeySelectorThrows() {
         TestSubscriber<Object> ts = TestSubscriber.create();
-        
+
         Observable.just(1, 2).toMap(new Func1<Integer, Integer>() {
             @Override
             public Integer call(Integer v) {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertError(TestException.class);
         ts.assertNoValues();
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testValueSelectorThrows() {
         TestSubscriber<Object> ts = TestSubscriber.create();
-        
+
         Observable.just(1, 2).toMap(new Func1<Integer, Integer>() {
             @Override
             public Integer call(Integer v) {
@@ -265,16 +265,16 @@ public Integer call(Integer v) {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertError(TestException.class);
         ts.assertNoValues();
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testMapFactoryThrows() {
         TestSubscriber<Object> ts = TestSubscriber.create();
-        
+
         Observable.just(1, 2).toMap(new Func1<Integer, Integer>() {
             @Override
             public Integer call(Integer v) {
@@ -291,12 +291,12 @@ public Map<Integer, Integer> call() {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertError(TestException.class);
         ts.assertNoValues();
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testFactoryFailureDoesNotAllowErrorAndCompletedEmissions() {
         TestSubscriber<Map<Integer, Integer>> ts = TestSubscriber.create(0);
@@ -327,7 +327,7 @@ public Integer call(Integer t) {
         ts.assertError(e);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testFactoryFailureDoesNotAllowTwoErrorEmissions() {
         try {
@@ -372,7 +372,7 @@ public Integer call(Integer t) {
             RxJavaHooks.reset();
         }
     }
-    
+
     @Test
     public void testFactoryFailureDoesNotAllowErrorThenOnNextEmissions() {
         TestSubscriber<Map<Integer, Integer>> ts = TestSubscriber.create(0);
@@ -403,7 +403,7 @@ public Integer call(Integer t) {
         ts.assertError(e);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testBackpressure() {
         TestSubscriber<Object> ts = TestSubscriber.create(0);
diff --git a/src/test/java/rx/internal/operators/OnSubscribeToMultimapTest.java b/src/test/java/rx/internal/operators/OnSubscribeToMultimapTest.java
index 6177014bec..91fb03c0be 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeToMultimapTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToMultimapTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -139,7 +139,7 @@ protected boolean removeEldestEntry(Map.Entry<Integer, Collection<String>> eldes
         verify(objectObserver, times(1)).onNext(expected);
         verify(objectObserver, times(1)).onCompleted();
     }
-    
+
     private static final <K,V> Func1<K, Collection<V>> arrayListCollectionFactory() {
         return new Func1<K, Collection<V>>() {
 
@@ -148,7 +148,7 @@ public Collection<V> call(K k) {
                 return new ArrayList<V>();
             }};
     }
-    
+
     private static final <K, V> Func0<Map<K, Collection<V>>> multimapFactory() {
         return new Func0<Map<K, Collection<V>>>() {
 
@@ -296,27 +296,27 @@ public Collection<String> call(Integer t1) {
         verify(objectObserver, never()).onNext(expected);
         verify(objectObserver, never()).onCompleted();
     }
-    
+
     @Test
     public void testKeySelectorThrows() {
         TestSubscriber<Object> ts = TestSubscriber.create();
-        
+
         Observable.just(1, 2).toMultimap(new Func1<Integer, Integer>() {
             @Override
             public Integer call(Integer v) {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertError(TestException.class);
         ts.assertNoValues();
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testValueSelectorThrows() {
         TestSubscriber<Object> ts = TestSubscriber.create();
-        
+
         Observable.just(1, 2).toMultimap(new Func1<Integer, Integer>() {
             @Override
             public Integer call(Integer v) {
@@ -328,16 +328,16 @@ public Integer call(Integer v) {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertError(TestException.class);
         ts.assertNoValues();
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testMapFactoryThrows() {
         TestSubscriber<Object> ts = TestSubscriber.create();
-        
+
         Observable.just(1, 2).toMultimap(new Func1<Integer, Integer>() {
             @Override
             public Integer call(Integer v) {
@@ -354,16 +354,16 @@ public Map<Integer, Collection<Integer>> call() {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertError(TestException.class);
         ts.assertNoValues();
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testCollectionFactoryThrows() {
         TestSubscriber<Object> ts = TestSubscriber.create();
-        
+
         Observable.just(1, 2).toMultimap(new Func1<Integer, Integer>() {
             @Override
             public Integer call(Integer v) {
@@ -385,12 +385,12 @@ public Collection<Integer> call(Integer k) {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertError(TestException.class);
         ts.assertNoValues();
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testKeySelectorFailureDoesNotAllowErrorAndCompletedEmissions() {
         TestSubscriber<Map<Integer, Collection<Integer>>> ts = TestSubscriber.create(0);
@@ -421,7 +421,7 @@ public Integer call(Integer t) {
         ts.assertError(e);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testKeySelectorFailureDoesNotAllowTwoErrorEmissions() {
         try {
@@ -466,7 +466,7 @@ public Integer call(Integer t) {
             RxJavaHooks.reset();
         }
     }
-    
+
     @Test
     public void testFactoryFailureDoesNotAllowErrorThenOnNextEmissions() {
         TestSubscriber<Map<Integer, Collection<Integer>>> ts = TestSubscriber.create(0);
@@ -497,7 +497,7 @@ public Integer call(Integer t) {
         ts.assertError(e);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testBackpressure() {
         TestSubscriber<Object> ts = TestSubscriber.create(0);
@@ -512,5 +512,5 @@ public void testBackpressure() {
         ts.assertValueCount(1);
         ts.assertNoErrors();
         ts.assertCompleted();
-    }    
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
index b85a7c26a7..48d64b3b99 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToObservableFutureTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -132,80 +132,80 @@ public Object get(long timeout, TimeUnit unit) throws InterruptedException, Exec
         assertEquals(0, testSubscriber.getCompletions());
         assertEquals(0, testSubscriber.getOnNextEvents().size());
     }
-    
+
     @Test
     public void backpressure() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
-        
+
         FutureTask<Integer> f = new FutureTask<Integer>(new Runnable() {
             @Override
             public void run() {
-                
+
             }
         }, 1);
-        
+
         f.run();
-        
+
         Observable.from(f).subscribe(ts);
-        
+
         ts.assertNoValues();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void withTimeoutNoTimeout() {
         FutureTask<Integer> task = new FutureTask<Integer>(new Runnable() {
             @Override
             public void run() {
-                
+
             }
         }, 1);
-        
+
         task.run();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.from(task, 1, TimeUnit.SECONDS).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void withTimeoutTimeout() {
         FutureTask<Integer> task = new FutureTask<Integer>(new Runnable() {
             @Override
             public void run() {
-                
+
             }
         }, 1);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.from(task, 10, TimeUnit.MILLISECONDS).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TimeoutException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void withTimeoutNoTimeoutScheduler() {
         FutureTask<Integer> task = new FutureTask<Integer>(new Runnable() {
             @Override
             public void run() {
-                
+
             }
         }, 1);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.from(task, Schedulers.computation()).subscribe(ts);
 
         task.run();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java b/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
index 47b2338bbc..68b860d97f 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -37,7 +37,7 @@ public class OnSubscribeUsingTest {
 
     private interface Resource {
         String getTextFromWeb();
-        
+
         void dispose();
     }
 
@@ -325,15 +325,15 @@ public Observable<String> call(Resource resource) {
 
     }
 
-    
-    
+
+
     @Test
     public void testUsingDisposesEagerlyBeforeError() {
         final List<String> events = new ArrayList<String>();
         Func0<Resource> resourceFactory = createResourceFactory(events);
         final Action1<Throwable> onError = createOnErrorAction(events);
         final Action0 unsub = createUnsubAction(events);
-        
+
         Func1<Resource, Observable<String>> observableFactory = new Func1<Resource, Observable<String>>() {
             @Override
             public Observable<String> call(Resource resource) {
@@ -351,14 +351,14 @@ public Observable<String> call(Resource resource) {
         assertEquals(Arrays.asList("disposed", "error", "unsub"), events);
 
     }
-    
+
     @Test
     public void testUsingDoesNotDisposesEagerlyBeforeError() {
         final List<String> events = new ArrayList<String>();
         Func0<Resource> resourceFactory = createResourceFactory(events);
         final Action1<Throwable> onError = createOnErrorAction(events);
         final Action0 unsub = createUnsubAction(events);
-        
+
         Func1<Resource, Observable<String>> observableFactory = new Func1<Resource, Observable<String>>() {
             @Override
             public Observable<String> call(Resource resource) {
@@ -413,7 +413,7 @@ public void dispose() {
             }
         };
     }
-    
+
     private static Action0 createOnCompletedAction(final List<String> events) {
         return new Action0() {
             @Override
@@ -422,27 +422,27 @@ public void call() {
             }
         };
     }
-    
+
     @Test
     public void factoryThrows() {
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         final AtomicInteger count = new AtomicInteger();
-        
+
         Observable.<Integer, Integer>using(
                 new Func0<Integer>() {
                     @Override
                     public Integer call() {
                         return 1;
                     }
-                }, 
+                },
                 new Func1<Integer, Observable<Integer>>() {
                     @Override
-                    public Observable<Integer> call(Integer v) { 
-                        throw new TestException("forced failure"); 
+                    public Observable<Integer> call(Integer v) {
+                        throw new TestException("forced failure");
                     }
-                }, 
+                },
                 new Action1<Integer>() {
                     @Override
                     public void call(Integer c) {
@@ -451,32 +451,32 @@ public void call(Integer c) {
                 }
         )
         .unsafeSubscribe(ts);
-        
+
         ts.assertError(TestException.class);
-        
+
         Assert.assertEquals(1, count.get());
     }
-    
+
     @Test
     public void nonEagerTermination() {
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         final AtomicInteger count = new AtomicInteger();
-        
+
         Observable.<Integer, Integer>using(
                 new Func0<Integer>() {
                     @Override
                     public Integer call() {
                         return 1;
                     }
-                }, 
+                },
                 new Func1<Integer, Observable<Integer>>() {
                     @Override
-                    public Observable<Integer> call(Integer v) { 
+                    public Observable<Integer> call(Integer v) {
                         return Observable.just(v);
                     }
-                }, 
+                },
                 new Action1<Integer>() {
                     @Override
                     public void call(Integer c) {
@@ -485,11 +485,11 @@ public void call(Integer c) {
                 }, false
         )
         .unsafeSubscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         Assert.assertEquals(1, count.get());
     }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorAllTest.java b/src/test/java/rx/internal/operators/OperatorAllTest.java
index 0a22203d18..264c0abc88 100644
--- a/src/test/java/rx/internal/operators/OperatorAllTest.java
+++ b/src/test/java/rx/internal/operators/OperatorAllTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -134,7 +134,7 @@ public Observable<Integer> call(Boolean t1) {
         });
         assertEquals((Object)2, source.toBlocking().first());
     }
-    
+
     @Test
     public void testBackpressureIfNoneRequestedNoneShouldBeDelivered() {
         TestSubscriber<Boolean> ts = new TestSubscriber<Boolean>(0);
@@ -148,7 +148,7 @@ public Boolean call(Object t1) {
         ts.assertNoErrors();
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testBackpressureIfOneRequestedOneShouldBeDelivered() {
         TestSubscriber<Boolean> ts = new TestSubscriber<Boolean>(1);
@@ -163,7 +163,7 @@ public Boolean call(Object object) {
         ts.assertCompleted();
         ts.assertValue(true);
     }
-    
+
     @Test
     public void testPredicateThrowsExceptionAndValueInCauseMessage() {
         TestSubscriber<Boolean> ts = new TestSubscriber<Boolean>(0);
@@ -182,7 +182,7 @@ public Boolean call(Object object) {
         assertEquals(ex, errors.get(0));
         assertTrue(ex.getCause().getMessage().contains("Boo!"));
     }
-    
+
     @Test
     public void testDoesNotEmitMultipleTerminalEvents() {
         TestSubscriber<Boolean> ts = TestSubscriber.create();
@@ -212,7 +212,7 @@ public Boolean call(Integer t) {
         ts.assertError(RuntimeException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testUpstreamEmitsOnNextAfterFailureWithoutCheckingSubscription() {
         TestSubscriber<Boolean> ts = TestSubscriber.create();
@@ -240,7 +240,7 @@ public Boolean call(Integer t) {
                     throw new RuntimeException("boo");
                 else  {
                     once = false;
-                    return true; 
+                    return true;
                 }
             }})
         .unsafeSubscribe(ts);
@@ -248,7 +248,7 @@ public Boolean call(Integer t) {
         ts.assertError(RuntimeException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testDoesNotEmitMultipleErrorEventsAndReportsSecondErrorToHooks() {
         try {
diff --git a/src/test/java/rx/internal/operators/OperatorAnyTest.java b/src/test/java/rx/internal/operators/OperatorAnyTest.java
index 85f1cd3c93..7ddbfa6a23 100644
--- a/src/test/java/rx/internal/operators/OperatorAnyTest.java
+++ b/src/test/java/rx/internal/operators/OperatorAnyTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -226,7 +226,7 @@ public Observable<Integer> call(Boolean t1) {
         });
         assertEquals((Object)2, source.toBlocking().first());
     }
-    
+
     @Test
     public void testBackpressureIfNoneRequestedNoneShouldBeDelivered() {
         TestSubscriber<Boolean> ts = new TestSubscriber<Boolean>(0);
@@ -240,7 +240,7 @@ public Boolean call(Object t1) {
         ts.assertNoErrors();
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testBackpressureIfOneRequestedOneShouldBeDelivered() {
         TestSubscriber<Boolean> ts = new TestSubscriber<Boolean>(1);
@@ -255,7 +255,7 @@ public Boolean call(Object object) {
         ts.assertCompleted();
         ts.assertValue(true);
     }
-    
+
     @Test
     public void testPredicateThrowsExceptionAndValueInCauseMessage() {
         TestSubscriber<Boolean> ts = new TestSubscriber<Boolean>(0);
@@ -274,7 +274,7 @@ public Boolean call(Object object) {
         assertEquals(ex, errors.get(0));
         assertTrue(ex.getCause().getMessage().contains("Boo!"));
     }
-    
+
     @Test
     public void testUpstreamEmitsOnNextAfterFailureWithoutCheckingSubscription() {
         TestSubscriber<Boolean> ts = TestSubscriber.create();
@@ -302,7 +302,7 @@ public Boolean call(Integer t) {
                     throw new RuntimeException("boo");
                 else  {
                     once = false;
-                    return true; 
+                    return true;
                 }
             }})
         .unsafeSubscribe(ts);
@@ -310,7 +310,7 @@ public Boolean call(Integer t) {
         ts.assertError(RuntimeException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testUpstreamEmitsOnNextWithoutCheckingSubscription() {
         TestSubscriber<Boolean> ts = TestSubscriber.create();
@@ -341,7 +341,7 @@ public Boolean call(Integer t) {
         assertEquals(1, ts.getCompletions());
         ts.assertNoErrors();
     }
-    
+
     @Test
     public void testDoesNotEmitMultipleErrorEventsAndReportsSecondErrorToHooks() {
         try {
diff --git a/src/test/java/rx/internal/operators/OperatorAsObservableTest.java b/src/test/java/rx/internal/operators/OperatorAsObservableTest.java
index 30f5d3cf84..1b19d6f054 100644
--- a/src/test/java/rx/internal/operators/OperatorAsObservableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorAsObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -33,19 +33,19 @@ public class OperatorAsObservableTest {
     @Test
     public void testHiding() {
         PublishSubject<Integer> src = PublishSubject.create();
-        
+
         Observable<Integer> dst = src.asObservable();
-        
+
         assertFalse(dst instanceof PublishSubject);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         dst.subscribe(o);
-        
+
         src.onNext(1);
         src.onCompleted();
-        
+
         verify(o).onNext(1);
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
@@ -53,18 +53,18 @@ public void testHiding() {
     @Test
     public void testHidingError() {
         PublishSubject<Integer> src = PublishSubject.create();
-        
+
         Observable<Integer> dst = src.asObservable();
-        
+
         assertFalse(dst instanceof PublishSubject);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         dst.subscribe(o);
-        
+
         src.onError(new TestException());
-        
+
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
         verify(o).onError(any(TestException.class));
diff --git a/src/test/java/rx/internal/operators/OperatorBufferTest.java b/src/test/java/rx/internal/operators/OperatorBufferTest.java
index 1c0202e9ed..2a14f7797e 100644
--- a/src/test/java/rx/internal/operators/OperatorBufferTest.java
+++ b/src/test/java/rx/internal/operators/OperatorBufferTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -512,30 +512,30 @@ public void bufferWithBOBoundaryThrows() {
     @Test(timeout = 2000)
     public void bufferWithSizeTake1() {
         Observable<Integer> source = Observable.just(1).repeat();
-        
+
         Observable<List<Integer>> result = source.buffer(2).take(1);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         verify(o).onNext(Arrays.asList(1, 1));
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test(timeout = 2000)
     public void bufferWithSizeSkipTake1() {
         Observable<Integer> source = Observable.just(1).repeat();
-        
+
         Observable<List<Integer>> result = source.buffer(2, 3).take(1);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         verify(o).onNext(Arrays.asList(1, 1));
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
@@ -543,16 +543,16 @@ public void bufferWithSizeSkipTake1() {
     @Test(timeout = 2000)
     public void bufferWithTimeTake1() {
         Observable<Long> source = Observable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
-        
+
         Observable<List<Long>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler).take(1);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
-        
+
         verify(o).onNext(Arrays.asList(0L, 1L));
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
@@ -560,17 +560,17 @@ public void bufferWithTimeTake1() {
     @Test(timeout = 2000)
     public void bufferWithTimeSkipTake2() {
         Observable<Long> source = Observable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
-        
+
         Observable<List<Long>> result = source.buffer(100, 60, TimeUnit.MILLISECONDS, scheduler).take(2);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         result.subscribe(o);
-        
+
         scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
-        
+
         inOrder.verify(o).onNext(Arrays.asList(0L, 1L));
         inOrder.verify(o).onNext(Arrays.asList(1L, 2L));
         inOrder.verify(o).onCompleted();
@@ -580,24 +580,24 @@ public void bufferWithTimeSkipTake2() {
     public void bufferWithBoundaryTake2() {
         Observable<Long> boundary = Observable.interval(60, 60, TimeUnit.MILLISECONDS, scheduler);
         Observable<Long> source = Observable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
-        
+
         Observable<List<Long>> result = source.buffer(boundary).take(2);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         result.subscribe(o);
-        
+
         scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
-        
+
         inOrder.verify(o).onNext(Arrays.asList(0L));
         inOrder.verify(o).onNext(Arrays.asList(1L));
         inOrder.verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
-        
+
     }
-    
+
     @Test(timeout = 2000)
     public void bufferWithStartEndBoundaryTake2() {
         Observable<Long> start = Observable.interval(61, 61, TimeUnit.MILLISECONDS, scheduler);
@@ -607,19 +607,19 @@ public Observable<Long> call(Long t1) {
                 return Observable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler);
             }
         };
-        
+
         Observable<Long> source = Observable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
-        
+
         Observable<List<Long>> result = source.buffer(start, end).take(2);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         result.subscribe(o);
-        
+
         scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
-        
+
         inOrder.verify(o).onNext(Arrays.asList(1L, 2L, 3L));
         inOrder.verify(o).onNext(Arrays.asList(3L, 4L));
         inOrder.verify(o).onCompleted();
@@ -628,68 +628,68 @@ public Observable<Long> call(Long t1) {
     @Test
     public void bufferWithSizeThrows() {
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         Observable<List<Integer>> result = source.buffer(2);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
         source.onError(new TestException());
-        
+
         inOrder.verify(o).onNext(Arrays.asList(1, 2));
         inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(Arrays.asList(3));
         verify(o, never()).onCompleted();
-                
+
     }
-    
+
     @Test
     public void bufferWithTimeThrows() {
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         Observable<List<Integer>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         source.onNext(2);
         scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
         source.onNext(3);
         source.onError(new TestException());
         scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
-        
+
         inOrder.verify(o).onNext(Arrays.asList(1, 2));
         inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(Arrays.asList(3));
         verify(o, never()).onCompleted();
-                
+
     }
     @Test
     public void bufferWithTimeAndSize() {
         Observable<Long> source = Observable.interval(30, 30, TimeUnit.MILLISECONDS, scheduler);
-        
+
         Observable<List<Long>> result = source.buffer(100, TimeUnit.MILLISECONDS, 2, scheduler).take(3);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         result.subscribe(o);
-        
+
         scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
-        
+
         inOrder.verify(o).onNext(Arrays.asList(0L, 1L));
         inOrder.verify(o).onNext(Arrays.asList(2L));
         inOrder.verify(o).onCompleted();
@@ -698,7 +698,7 @@ public void bufferWithTimeAndSize() {
     @Test
     public void bufferWithStartEndStartThrows() {
         PublishSubject<Integer> start = PublishSubject.create();
-        
+
         Func1<Integer, Observable<Integer>> end = new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t1) {
@@ -709,17 +709,17 @@ public Observable<Integer> call(Integer t1) {
         PublishSubject<Integer> source = PublishSubject.create();
 
         Observable<List<Integer>> result = source.buffer(start, end);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         start.onNext(1);
         source.onNext(1);
         source.onNext(2);
         start.onError(new TestException());
-        
+
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
         verify(o).onError(any(TestException.class));
@@ -727,7 +727,7 @@ public Observable<Integer> call(Integer t1) {
     @Test
     public void bufferWithStartEndEndFunctionThrows() {
         PublishSubject<Integer> start = PublishSubject.create();
-        
+
         Func1<Integer, Observable<Integer>> end = new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t1) {
@@ -738,16 +738,16 @@ public Observable<Integer> call(Integer t1) {
         PublishSubject<Integer> source = PublishSubject.create();
 
         Observable<List<Integer>> result = source.buffer(start, end);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         start.onNext(1);
         source.onNext(1);
         source.onNext(2);
-        
+
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
         verify(o).onError(any(TestException.class));
@@ -755,7 +755,7 @@ public Observable<Integer> call(Integer t1) {
     @Test
     public void bufferWithStartEndEndThrows() {
         PublishSubject<Integer> start = PublishSubject.create();
-        
+
         Func1<Integer, Observable<Integer>> end = new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t1) {
@@ -766,16 +766,16 @@ public Observable<Integer> call(Integer t1) {
         PublishSubject<Integer> source = PublishSubject.create();
 
         Observable<List<Integer>> result = source.buffer(start, end);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         result.subscribe(o);
-        
+
         start.onNext(1);
         source.onNext(1);
         source.onNext(2);
-        
+
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
         verify(o).onError(any(TestException.class));
@@ -971,8 +971,8 @@ public void onNext(List<Integer> t) {
     public void testBufferWithTimeDoesntUnsubscribeDownstream() throws InterruptedException {
         @SuppressWarnings("unchecked")
         final Observer<Object> o = mock(Observer.class);
-        
-        
+
+
         final CountDownLatch cdl = new CountDownLatch(1);
         Subscriber<Object> s = new Subscriber<Object>() {
             @Override
@@ -990,33 +990,33 @@ public void onCompleted() {
                 cdl.countDown();
             }
         };
-        
+
         Observable.range(1, 1).delay(1, TimeUnit.SECONDS).buffer(2, TimeUnit.SECONDS).unsafeSubscribe(s);
-        
+
         cdl.await();
-        
+
         verify(o).onNext(Arrays.asList(1));
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
-        
+
         assertFalse(s.isUnsubscribed());
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void testPostCompleteBackpressure() {
         Observable<List<Integer>> source = Observable.range(1, 10).buffer(3, 1);
-        
+
         TestSubscriber<List<Integer>> ts = TestSubscriber.create(0L);
-        
+
         source.subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertNoErrors();
-        
+
         ts.requestMore(7);
-        
+
         ts.assertValues(
                 Arrays.asList(1, 2, 3),
                 Arrays.asList(2, 3, 4),
@@ -1043,7 +1043,7 @@ public void testPostCompleteBackpressure() {
         );
         ts.assertNotCompleted();
         ts.assertNoErrors();
-        
+
         ts.requestMore(1);
 
         ts.assertValues(
@@ -1059,7 +1059,7 @@ public void testPostCompleteBackpressure() {
         );
         ts.assertNotCompleted();
         ts.assertNoErrors();
-        
+
         ts.requestMore(1);
 
         ts.assertValues(
@@ -1077,35 +1077,35 @@ public void testPostCompleteBackpressure() {
         ts.assertCompleted();
         ts.assertNoErrors();
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void timeAndSkipOverlap() {
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         TestSubscriber<List<Integer>> ts = TestSubscriber.create();
-        
+
         ps.buffer(2, 1, TimeUnit.SECONDS, scheduler).subscribe(ts);
-        
+
         ps.onNext(1);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         ps.onNext(2);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
         ps.onNext(3);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
         ps.onNext(4);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         ps.onCompleted();
-        
+
         ts.assertValues(
                 Arrays.asList(1, 2),
                 Arrays.asList(2, 3),
@@ -1113,84 +1113,84 @@ public void timeAndSkipOverlap() {
                 Arrays.asList(4),
                 Collections.<Integer>emptyList()
         );
-        
+
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void timeAndSkipSkip() {
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         TestSubscriber<List<Integer>> ts = TestSubscriber.create();
-        
+
         ps.buffer(2, 3, TimeUnit.SECONDS, scheduler).subscribe(ts);
-        
+
         ps.onNext(1);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         ps.onNext(2);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
         ps.onNext(3);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
         ps.onNext(4);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         ps.onCompleted();
-        
+
         ts.assertValues(
                 Arrays.asList(1, 2),
                 Arrays.asList(4)
         );
-        
+
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void timeAndSkipOverlapScheduler() {
-        
+
         RxJavaHooks.setOnComputationScheduler(new Func1<Scheduler, Scheduler>() {
             @Override
             public Scheduler call(Scheduler t) {
                 return scheduler;
             }
         });
-        
+
         try {
             PublishSubject<Integer> ps = PublishSubject.create();
-            
+
             TestSubscriber<List<Integer>> ts = TestSubscriber.create();
-            
+
             ps.buffer(2, 1, TimeUnit.SECONDS).subscribe(ts);
-            
+
             ps.onNext(1);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            
+
             ps.onNext(2);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-    
+
             ps.onNext(3);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-    
+
             ps.onNext(4);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            
+
             ps.onCompleted();
-            
+
             ts.assertValues(
                     Arrays.asList(1, 2),
                     Arrays.asList(2, 3),
@@ -1198,14 +1198,14 @@ public Scheduler call(Scheduler t) {
                     Arrays.asList(4),
                     Collections.<Integer>emptyList()
             );
-            
+
             ts.assertNoErrors();
             ts.assertCompleted();
         } finally {
             RxJavaHooks.reset();
         }
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void timeAndSkipSkipDefaultScheduler() {
@@ -1215,38 +1215,38 @@ public Scheduler call(Scheduler t) {
                 return scheduler;
             }
         });
-        
+
         try {
-        
+
             PublishSubject<Integer> ps = PublishSubject.create();
-            
+
             TestSubscriber<List<Integer>> ts = TestSubscriber.create();
-            
+
             ps.buffer(2, 3, TimeUnit.SECONDS).subscribe(ts);
-            
+
             ps.onNext(1);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            
+
             ps.onNext(2);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-    
+
             ps.onNext(3);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-    
+
             ps.onNext(4);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            
+
             ps.onCompleted();
-            
+
             ts.assertValues(
                     Arrays.asList(1, 2),
                     Arrays.asList(4)
             );
-            
+
             ts.assertNoErrors();
             ts.assertCompleted();
         } finally {
diff --git a/src/test/java/rx/internal/operators/OperatorCastTest.java b/src/test/java/rx/internal/operators/OperatorCastTest.java
index d67c1abfa4..e832d21c11 100644
--- a/src/test/java/rx/internal/operators/OperatorCastTest.java
+++ b/src/test/java/rx/internal/operators/OperatorCastTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -51,22 +51,22 @@ public void testCastWithWrongType() {
         verify(observer, times(1)).onError(
                 org.mockito.Matchers.any(ClassCastException.class));
     }
-    
+
     @Test
     public void castCrashUnsubscribes() {
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         TestSubscriber<String> ts = TestSubscriber.create();
-        
+
         ps.cast(String.class).unsafeSubscribe(ts);
-        
+
         Assert.assertTrue("Not subscribed?", ps.hasObservers());
-        
+
         ps.onNext(1);
-        
+
         Assert.assertFalse("Subscribed?", ps.hasObservers());
-        
+
         ts.assertError(ClassCastException.class);
     }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorConcatTest.java b/src/test/java/rx/internal/operators/OperatorConcatTest.java
index 06b889a4e8..99f4ae1a25 100644
--- a/src/test/java/rx/internal/operators/OperatorConcatTest.java
+++ b/src/test/java/rx/internal/operators/OperatorConcatTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -75,14 +75,14 @@ public void testConcatWithList() {
 
         verify(observer, times(7)).onNext(anyString());
     }
-    
+
     @Test
     public void testConcatMapIterable() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
 
         final String[] l = { "a", "b", "c", "d", "e" };
-        
+
         Func1<List<String>,List<String>> identity = new Func1<List<String>, List<String>>() {
 			@Override
 			public List<String> call(List<String> t) {
@@ -92,7 +92,7 @@ public List<String> call(List<String> t) {
 
         final Observable<List<String>> listObs = Observable.just(Arrays.asList(l));
         final Observable<String> concatMap = listObs.concatMapIterable(identity);
-        
+
         concatMap.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -610,7 +610,7 @@ public void testMultipleObservers() {
         verify(o1, never()).onError(any(Throwable.class));
         verify(o2, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void concatVeryLongObservableOfObservables() {
         final int n = 10000;
@@ -626,13 +626,13 @@ public void call(Subscriber<? super Observable<Integer>> s) {
                 s.onCompleted();
             }
         });
-        
+
         Observable<List<Integer>> result = Observable.concat(source).toList();
-        
+
         @SuppressWarnings("unchecked")
         Observer<List<Integer>> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         result.subscribe(o);
 
         List<Integer> list = new ArrayList<Integer>(n);
@@ -658,13 +658,13 @@ public void call(Subscriber<? super Observable<Integer>> s) {
                 s.onCompleted();
             }
         });
-        
+
         Observable<List<Integer>> result = Observable.concat(source).take(n / 2).toList();
-        
+
         @SuppressWarnings("unchecked")
         Observer<List<Integer>> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         result.subscribe(o);
 
         List<Integer> list = new ArrayList<Integer>(n);
@@ -675,7 +675,7 @@ public void call(Subscriber<? super Observable<Integer>> s) {
         inOrder.verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testConcatOuterBackpressure() {
         assertEquals(1,
@@ -684,7 +684,7 @@ public void testConcatOuterBackpressure() {
                         .take(1)
                         .toBlocking().single());
     }
-    
+
     @Test
     public void testInnerBackpressureWithAlignedBoundaries() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -701,7 +701,7 @@ public void testInnerBackpressureWithAlignedBoundaries() {
     /*
      * Testing without counts aligned with buffer sizes because concat must prevent the subscription
      * to the next Observable if request == 0 which can happen at the end of a subscription
-     * if the request size == emitted size. It needs to delay subscription until the next request when aligned, 
+     * if the request size == emitted size. It needs to delay subscription until the next request when aligned,
      * when not aligned, it just subscribesNext with the outstanding request amount.
      */
     @Test
@@ -716,7 +716,7 @@ public void testInnerBackpressureWithoutAlignedBoundaries() {
         ts.assertNoErrors();
         assertEquals((RxRingBuffer.SIZE * 4) + 20, ts.getOnNextEvents().size());
     }
-    
+
     // https://github.com/ReactiveX/RxJava/issues/1818
     @Test
     public void testConcatWithNonCompliantSourceDoubleOnComplete() {
@@ -728,9 +728,9 @@ public void call(Subscriber<? super String> s) {
                 s.onCompleted();
                 s.onCompleted();
             }
-            
+
         });
-        
+
         TestSubscriber<String> ts = new TestSubscriber<String>();
         Observable.concat(o, o).subscribe(ts);
         ts.awaitTerminalEvent(500, TimeUnit.MILLISECONDS);
@@ -786,10 +786,10 @@ public void onError(Throwable e) {
         });
 
         executor.awaitTermination(12000, TimeUnit.MILLISECONDS);
-        
+
         assertEquals(n, counter.get());
     }
-    
+
     @Test
     public void testRequestOverflowDoesNotStallStream() {
         Observable<Integer> o1 = Observable.just(1,2,3);
@@ -804,17 +804,17 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                
+
             }
 
             @Override
             public void onNext(Integer t) {
                 request(2);
             }});
-        
+
         assertTrue(completed.get());
     }
-    
+
     @Test//(timeout = 100000)
     public void concatMapRangeAsyncLoopIssue2876() {
         final long durationSeconds = 2;
@@ -843,32 +843,32 @@ public Observable<Integer> call(Integer t) {
             assertEquals((Integer)999, ts.getOnNextEvents().get(999));
         }
     }
-    
+
     @Test
     public void scalarAndRangeBackpressured() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         Observable.just(1).concatWith(Observable.range(2, 3)).subscribe(ts);
-        
+
         ts.assertNoValues();
-        
+
         ts.requestMore(5);
-        
+
         ts.assertValues(1, 2, 3, 4);
         ts.assertCompleted();
         ts.assertNoErrors();
     }
-    
+
     @Test
     public void scalarAndEmptyBackpressured() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         Observable.just(1).concatWith(Observable.<Integer>empty()).subscribe(ts);
-        
+
         ts.assertNoValues();
-        
+
         ts.requestMore(5);
-        
+
         ts.assertValue(1);
         ts.assertCompleted();
         ts.assertNoErrors();
@@ -877,13 +877,13 @@ public void scalarAndEmptyBackpressured() {
     @Test
     public void rangeAndEmptyBackpressured() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         Observable.range(1, 2).concatWith(Observable.<Integer>empty()).subscribe(ts);
-        
+
         ts.assertNoValues();
-        
+
         ts.requestMore(5);
-        
+
         ts.assertValues(1, 2);
         ts.assertCompleted();
         ts.assertNoErrors();
@@ -892,13 +892,13 @@ public void rangeAndEmptyBackpressured() {
     @Test
     public void emptyAndScalarBackpressured() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         Observable.<Integer>empty().concatWith(Observable.just(1)).subscribe(ts);
-        
+
         ts.assertNoValues();
-        
+
         ts.requestMore(5);
-        
+
         ts.assertValue(1);
         ts.assertCompleted();
         ts.assertNoErrors();
@@ -910,32 +910,32 @@ public void concatMany() throws Exception {
         for (int i = 2; i < 10; i++) {
             Class<?>[] clazz = new Class[i];
             Arrays.fill(clazz, Observable.class);
-            
+
             Observable<Integer>[] obs = new Observable[i];
             Arrays.fill(obs, Observable.just(1));
-            
+
             Integer[] expected = new Integer[i];
             Arrays.fill(expected, 1);
-            
+
             Method m = Observable.class.getMethod("concat", clazz);
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             ((Observable<Integer>)m.invoke(null, (Object[])obs)).subscribe(ts);
-            
+
             ts.assertValues(expected);
             ts.assertNoErrors();
             ts.assertCompleted();
         }
     }
-    
+
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @Test
     public void concatMapJustJust() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(Observable.just(1)).concatMap((Func1)UtilityFunctions.identity()).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -945,21 +945,21 @@ public void concatMapJustJust() {
     @Test
     public void concatMapJustRange() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(Observable.range(1, 5)).concatMap((Func1)UtilityFunctions.identity()).subscribe(ts);
-        
+
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @Test
     public void concatMapDelayErrorJustJust() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(Observable.just(1)).concatMapDelayError((Func1)UtilityFunctions.identity()).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -969,33 +969,33 @@ public void concatMapDelayErrorJustJust() {
     @Test
     public void concatMapDelayErrorJustRange() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(Observable.range(1, 5)).concatMapDelayError((Func1)UtilityFunctions.identity()).subscribe(ts);
-        
+
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void startWith() throws Exception {
         for (int i = 2; i < 10; i++) {
             Class<?>[] clazz = new Class[i];
             Arrays.fill(clazz, Object.class);
-            
+
             Object[] obs = new Object[i];
             Arrays.fill(obs, 1);
-            
+
             Integer[] expected = new Integer[i];
             Arrays.fill(expected, 1);
-            
+
             Method m = Observable.class.getMethod("startWith", clazz);
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             ((Observable<Integer>)m.invoke(Observable.empty(), obs)).subscribe(ts);
-            
+
             ts.assertValues(expected);
             ts.assertNoErrors();
             ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorDebounceTest.java b/src/test/java/rx/internal/operators/OperatorDebounceTest.java
index 4a33c662cd..ae509c743d 100644
--- a/src/test/java/rx/internal/operators/OperatorDebounceTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDebounceTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -247,17 +247,17 @@ public Observable<Integer> call(Integer t1) {
     @Test
     public void debounceTimedLastIsNotLost() {
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         source.debounce(100, TimeUnit.MILLISECONDS, scheduler).subscribe(o);
-        
+
         source.onNext(1);
         source.onCompleted();
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         verify(o).onNext(1);
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
@@ -279,7 +279,7 @@ public Observable<Integer> call(Integer t1) {
         Observer<Object> o = mock(Observer.class);
 
         source.debounce(debounceSel).subscribe(o);
-        
+
         source.onNext(1);
         source.onCompleted();
 
@@ -305,10 +305,10 @@ public void debounceWithTimeBackpressure() throws InterruptedException {
         subscriber.assertTerminalEvent();
         subscriber.assertNoErrors();
     }
-    
+
     @Test
     public void debounceDefaultScheduler() throws Exception {
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
 
         Observable.range(1, 1000).debounce(1, TimeUnit.SECONDS).subscribe(ts);
diff --git a/src/test/java/rx/internal/operators/OperatorDefaultIfEmptyTest.java b/src/test/java/rx/internal/operators/OperatorDefaultIfEmptyTest.java
index ec6bb0486f..fc20f350df 100644
--- a/src/test/java/rx/internal/operators/OperatorDefaultIfEmptyTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDefaultIfEmptyTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -54,17 +54,17 @@ public void testDefaultIfEmptyWithEmpty() {
         @SuppressWarnings("unchecked")
         Observer<Integer> observer = mock(Observer.class);
         observable.subscribe(observer);
-        
+
         verify(observer).onNext(10);
         verify(observer).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testEmptyButClientThrows() {
         @SuppressWarnings("unchecked")
         final Observer<Integer> o = mock(Observer.class);
-        
+
         Observable.<Integer>empty().defaultIfEmpty(1).subscribe(new Subscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
@@ -81,12 +81,12 @@ public void onCompleted() {
                 o.onCompleted();
             }
         });
-        
+
         verify(o).onError(any(TestException.class));
         verify(o, never()).onNext(any(Integer.class));
         verify(o, never()).onCompleted();
     }
-    
+
     @Test
     public void testBackpressureEmpty() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
@@ -97,7 +97,7 @@ public void testBackpressureEmpty() {
         ts.assertValue(1);
         ts.assertCompleted();
     }
-    
+
     @Test
     public void testBackpressureNonEmpty() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
diff --git a/src/test/java/rx/internal/operators/OperatorDelayTest.java b/src/test/java/rx/internal/operators/OperatorDelayTest.java
index 470e83ddc5..d92aac8569 100644
--- a/src/test/java/rx/internal/operators/OperatorDelayTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDelayTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -690,7 +690,7 @@ public Integer call(Integer t) {
         ts.assertNoErrors();
         assertEquals(RxRingBuffer.SIZE * 2, ts.getOnNextEvents().size());
     }
-    
+
     @Test
     public void testBackpressureWithSubscriptionTimedDelay() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -795,25 +795,25 @@ public Integer call(Integer t) {
         ts.assertNoErrors();
         assertEquals(RxRingBuffer.SIZE * 2, ts.getOnNextEvents().size());
     }
-    
+
     @Test
     public void testErrorRunsBeforeOnNext() {
         TestScheduler test = Schedulers.test();
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         ps.delay(1, TimeUnit.SECONDS, test).subscribe(ts);
-        
+
         ps.onNext(1);
-        
+
         test.advanceTimeBy(500, TimeUnit.MILLISECONDS);
-        
+
         ps.onError(new TestException());
-        
+
         test.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -822,13 +822,13 @@ public void testErrorRunsBeforeOnNext() {
     @Test
     public void delaySubscriptionCancelBeforeTime() {
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.delaySubscription(100, TimeUnit.MILLISECONDS, scheduler).subscribe(ts);
-        
+
         Assert.assertFalse("source subscribed?", source.hasObservers());
-        
+
         ts.unsubscribe();
 
         Assert.assertFalse("source subscribed?", source.hasObservers());
diff --git a/src/test/java/rx/internal/operators/OperatorDematerializeTest.java b/src/test/java/rx/internal/operators/OperatorDematerializeTest.java
index 7b805d63c0..8a21a34938 100644
--- a/src/test/java/rx/internal/operators/OperatorDematerializeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDematerializeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -112,30 +112,30 @@ public void testCompletePassThru() {
     @Test
     public void testHonorsContractWhenCompleted() {
         Observable<Integer> source = Observable.just(1);
-        
+
         Observable<Integer> result = source.materialize().dematerialize();
-        
+
         @SuppressWarnings("unchecked")
         Observer<Integer> o = mock(Observer.class);
-        
+
         result.unsafeSubscribe(Subscribers.from(o));
-        
+
         verify(o).onNext(1);
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testHonorsContractWhenThrows() {
         Observable<Integer> source = Observable.error(new TestException());
-        
+
         Observable<Integer> result = source.materialize().dematerialize();
-        
+
         @SuppressWarnings("unchecked")
         Observer<Integer> o = mock(Observer.class);
-        
+
         result.unsafeSubscribe(Subscribers.from(o));
-        
+
         verify(o, never()).onNext(any(Integer.class));
         verify(o, never()).onCompleted();
         verify(o).onError(any(TestException.class));
diff --git a/src/test/java/rx/internal/operators/OperatorDistinctTest.java b/src/test/java/rx/internal/operators/OperatorDistinctTest.java
index b0f128d29f..eee3a9d502 100644
--- a/src/test/java/rx/internal/operators/OperatorDistinctTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDistinctTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/OperatorDistinctUntilChangedTest.java b/src/test/java/rx/internal/operators/OperatorDistinctUntilChangedTest.java
index eddee0cc09..70f9abd45c 100644
--- a/src/test/java/rx/internal/operators/OperatorDistinctUntilChangedTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDistinctUntilChangedTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -47,7 +47,7 @@ public String call(String s) {
             return s.toUpperCase();
         }
     };
-    
+
     private final static Func1<String, String> THROWS_NON_FATAL = new Func1<String, String>() {
         @Override
         public String call(String s) {
@@ -142,7 +142,7 @@ public void testDistinctUntilChangedOfSourceWithExceptionsFromKeySelector() {
         inOrder.verify(w, never()).onNext(anyString());
         inOrder.verify(w, never()).onCompleted();
     }
-    
+
     @Test
     public void testDistinctUntilChangedWhenNonFatalExceptionThrownByKeySelectorIsNotReportedByUpstream() {
         Observable<String> src = Observable.just("a", "b", null, "c");
@@ -158,13 +158,13 @@ public void call(Throwable t) {
           .subscribe(w);
         assertFalse(errorOccurred.get());
     }
-    
+
     @Test
     public void customComparator() {
         Observable<String> source = Observable.just("a", "b", "B", "A","a", "C");
-        
+
         TestSubscriber<String> ts = TestSubscriber.create();
-        
+
         source.distinctUntilChanged(new Func2<String, String, Boolean>() {
             @Override
             public Boolean call(String a, String b) {
@@ -172,7 +172,7 @@ public Boolean call(String a, String b) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValues("a", "b", "A", "C");
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -181,9 +181,9 @@ public Boolean call(String a, String b) {
     @Test
     public void customComparatorThrows() {
         Observable<String> source = Observable.just("a", "b", "B", "A","a", "C");
-        
+
         TestSubscriber<String> ts = TestSubscriber.create();
-        
+
         source.distinctUntilChanged(new Func2<String, String, Boolean>() {
             @Override
             public Boolean call(String a, String b) {
@@ -191,7 +191,7 @@ public Boolean call(String a, String b) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue("a");
         ts.assertNotCompleted();
         ts.assertError(TestException.class);
diff --git a/src/test/java/rx/internal/operators/OperatorDoAfterTerminateTest.java b/src/test/java/rx/internal/operators/OperatorDoAfterTerminateTest.java
index d0dc6fa408..dd538ec552 100644
--- a/src/test/java/rx/internal/operators/OperatorDoAfterTerminateTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDoAfterTerminateTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -61,7 +61,7 @@ public void nullActionShouldBeCheckedInConstructor() {
             assertEquals("Action can not be null", expected.getMessage());
         }
     }
-    
+
     @Test
     public void nullFinallyActionShouldBeCheckedASAP() {
         try {
@@ -94,12 +94,12 @@ public void ifFinallyActionThrowsExceptionShouldNotBeSwallowedAndActionShouldBeC
         // Not only IllegalStateException was swallowed
         // But finallyAction was called twice!
     }
-    
+
     @SuppressWarnings("deprecation")
     @Test
     public void finallyDo() {
         Observable.empty().finallyDo(aAction0).subscribe();
-        
+
         verify(aAction0).call();
     }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java b/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
index 371b0826ed..3d1dcb4ca5 100644
--- a/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
@@ -89,15 +89,15 @@ public void onNext(Integer t) {
                 });
         assertEquals(Arrays.asList(3L,1L,2L,3L,4L,5L), requests);
     }
-    
+
     @Test
     public void dontRequestIfDownstreamRequestsLate() {
         final List<Long> requested = new ArrayList<Long>();
 
         Action1<Long> empty = Actions.empty();
-        
+
         final AtomicReference<Producer> producer = new AtomicReference<Producer>();
-        
+
         Observable.create(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
@@ -111,25 +111,25 @@ public void request(long n) {
         }).doOnRequest(empty).subscribe(new Subscriber<Object>() {
             @Override
             public void onNext(Object t) {
-                
+
             }
-            
+
             @Override
             public void onError(Throwable e) {
-                
+
             }
-            
+
             @Override
             public void onCompleted() {
-                
+
             }
-            
+
             @Override
             public void setProducer(Producer p) {
                 producer.set(p);
             }
         });
-        
+
         producer.get().request(1);
 
         int s = requested.size();
diff --git a/src/test/java/rx/internal/operators/OperatorDoOnSubscribeTest.java b/src/test/java/rx/internal/operators/OperatorDoOnSubscribeTest.java
index 49831352e1..4765a5dfe3 100644
--- a/src/test/java/rx/internal/operators/OperatorDoOnSubscribeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDoOnSubscribeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/OperatorDoOnUnsubscribeTest.java b/src/test/java/rx/internal/operators/OperatorDoOnUnsubscribeTest.java
index de2a9d93d5..7dc0a369d9 100644
--- a/src/test/java/rx/internal/operators/OperatorDoOnUnsubscribeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDoOnUnsubscribeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -32,7 +32,7 @@
 import rx.observers.TestSubscriber;
 
 public class OperatorDoOnUnsubscribeTest {
-    
+
     @Test
     public void testDoOnUnsubscribe() throws Exception {
         int subCount = 3;
diff --git a/src/test/java/rx/internal/operators/OperatorEagerConcatMapTest.java b/src/test/java/rx/internal/operators/OperatorEagerConcatMapTest.java
index 737b331dfe..acdf7b13fc 100644
--- a/src/test/java/rx/internal/operators/OperatorEagerConcatMapTest.java
+++ b/src/test/java/rx/internal/operators/OperatorEagerConcatMapTest.java
@@ -35,7 +35,7 @@
 public class OperatorEagerConcatMapTest {
     TestSubscriber<Object> ts;
     TestSubscriber<Object> tsBp;
-    
+
     Func1<Integer, Observable<Integer>> toJust = new Func1<Integer, Observable<Integer>>() {
         @Override
         public Observable<Integer> call(Integer t) {
@@ -55,11 +55,11 @@ public void before() {
         ts = new TestSubscriber<Object>();
         tsBp = new TestSubscriber<Object>(0L);
     }
-    
+
     @Test
     public void testSimple() {
         Observable.range(1, 100).concatMapEager(toJust).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertValueCount(100);
         ts.assertCompleted();
@@ -68,12 +68,12 @@ public void testSimple() {
     @Test
     public void testSimple2() {
         Observable.range(1, 100).concatMapEager(toRange).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertValueCount(200);
         ts.assertCompleted();
     }
-    
+
     @Test
     public void testEagerness2() {
         final AtomicInteger count = new AtomicInteger();
@@ -83,21 +83,21 @@ public void call(Integer t) {
                 count.getAndIncrement();
             }
         });
-        
+
         Observable.concatEager(source, source).subscribe(tsBp);
-        
+
         Assert.assertEquals(2, count.get());
         tsBp.assertNoErrors();
         tsBp.assertNotCompleted();
         tsBp.assertNoValues();
-        
+
         tsBp.requestMore(Long.MAX_VALUE);
-        
+
         tsBp.assertValueCount(count.get());
         tsBp.assertNoErrors();
         tsBp.assertCompleted();
     }
-    
+
     @Test
     public void testEagerness3() {
         final AtomicInteger count = new AtomicInteger();
@@ -107,16 +107,16 @@ public void call(Integer t) {
                 count.getAndIncrement();
             }
         });
-        
+
         Observable.concatEager(source, source, source).subscribe(tsBp);
-        
+
         Assert.assertEquals(3, count.get());
         tsBp.assertNoErrors();
         tsBp.assertNotCompleted();
         tsBp.assertNoValues();
-        
+
         tsBp.requestMore(Long.MAX_VALUE);
-        
+
         tsBp.assertValueCount(count.get());
         tsBp.assertNoErrors();
         tsBp.assertCompleted();
@@ -131,16 +131,16 @@ public void call(Integer t) {
                 count.getAndIncrement();
             }
         });
-        
+
         Observable.concatEager(source, source, source, source).subscribe(tsBp);
-        
+
         Assert.assertEquals(4, count.get());
         tsBp.assertNoErrors();
         tsBp.assertNotCompleted();
         tsBp.assertNoValues();
-        
+
         tsBp.requestMore(Long.MAX_VALUE);
-        
+
         tsBp.assertValueCount(count.get());
         tsBp.assertNoErrors();
         tsBp.assertCompleted();
@@ -155,16 +155,16 @@ public void call(Integer t) {
                 count.getAndIncrement();
             }
         });
-        
+
         Observable.concatEager(source, source, source, source, source).subscribe(tsBp);
-        
+
         Assert.assertEquals(5, count.get());
         tsBp.assertNoErrors();
         tsBp.assertNotCompleted();
         tsBp.assertNoValues();
-        
+
         tsBp.requestMore(Long.MAX_VALUE);
-        
+
         tsBp.assertValueCount(count.get());
         tsBp.assertNoErrors();
         tsBp.assertCompleted();
@@ -179,16 +179,16 @@ public void call(Integer t) {
                 count.getAndIncrement();
             }
         });
-        
+
         Observable.concatEager(source, source, source, source, source, source).subscribe(tsBp);
-        
+
         Assert.assertEquals(6, count.get());
         tsBp.assertNoErrors();
         tsBp.assertNotCompleted();
         tsBp.assertNoValues();
-        
+
         tsBp.requestMore(Long.MAX_VALUE);
-        
+
         tsBp.assertValueCount(count.get());
         tsBp.assertNoErrors();
         tsBp.assertCompleted();
@@ -203,16 +203,16 @@ public void call(Integer t) {
                 count.getAndIncrement();
             }
         });
-        
+
         Observable.concatEager(source, source, source, source, source, source, source).subscribe(tsBp);
-        
+
         Assert.assertEquals(7, count.get());
         tsBp.assertNoErrors();
         tsBp.assertNotCompleted();
         tsBp.assertNoValues();
-        
+
         tsBp.requestMore(Long.MAX_VALUE);
-        
+
         tsBp.assertValueCount(count.get());
         tsBp.assertNoErrors();
         tsBp.assertCompleted();
@@ -227,16 +227,16 @@ public void call(Integer t) {
                 count.getAndIncrement();
             }
         });
-        
+
         Observable.concatEager(source, source, source, source, source, source, source, source).subscribe(tsBp);
-        
+
         Assert.assertEquals(8, count.get());
         tsBp.assertNoErrors();
         tsBp.assertNotCompleted();
         tsBp.assertNoValues();
-        
+
         tsBp.requestMore(Long.MAX_VALUE);
-        
+
         tsBp.assertValueCount(count.get());
         tsBp.assertNoErrors();
         tsBp.assertCompleted();
@@ -251,16 +251,16 @@ public void call(Integer t) {
                 count.getAndIncrement();
             }
         });
-        
+
         Observable.concatEager(source, source, source, source, source, source, source, source, source).subscribe(tsBp);
-        
+
         Assert.assertEquals(9, count.get());
         tsBp.assertNoErrors();
         tsBp.assertNotCompleted();
         tsBp.assertNoValues();
-        
+
         tsBp.requestMore(Long.MAX_VALUE);
-        
+
         tsBp.assertValueCount(count.get());
         tsBp.assertNoErrors();
         tsBp.assertCompleted();
@@ -269,39 +269,39 @@ public void call(Integer t) {
     @Test
     public void testMainError() {
         Observable.<Integer>error(new TestException()).concatMapEager(toJust).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testInnerError() {
         Observable.concatEager(Observable.just(1), Observable.error(new TestException())).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testInnerEmpty() {
         Observable.concatEager(Observable.empty(), Observable.empty()).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void testMapperThrows() {
         Observable.just(1).concatMapEager(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t) {
                 throw new TestException();
-            } 
+            }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(TestException.class);
@@ -316,7 +316,7 @@ public void testInvalidCapacityHint() {
     public void testInvalidMaxConcurrent() {
         Observable.just(1).concatMapEager(toJust, RxRingBuffer.SIZE, 0);
     }
-    
+
     @Test
     public void testBackpressure() {
         Observable.concatEager(Observable.just(1), Observable.just(1)).subscribe(tsBp);
@@ -324,18 +324,18 @@ public void testBackpressure() {
         tsBp.assertNoErrors();
         tsBp.assertNoValues();
         tsBp.assertNotCompleted();
-        
+
         tsBp.requestMore(1);
         tsBp.assertValue(1);
         tsBp.assertNoErrors();
         tsBp.assertNotCompleted();
-        
+
         tsBp.requestMore(1);
         tsBp.assertValues(1, 1);
         tsBp.assertNoErrors();
         tsBp.assertCompleted();
     }
-    
+
     @Test
     public void testAsynchronousRun() {
         Observable.range(1, 2).concatMapEager(new Func1<Integer, Observable<Integer>>() {
@@ -344,18 +344,18 @@ public Observable<Integer> call(Integer t) {
                 return Observable.range(1, 1000).subscribeOn(Schedulers.computation());
             }
         }).observeOn(Schedulers.newThread()).subscribe(ts);
-        
+
         ts.awaitTerminalEvent();
         ts.assertNoErrors();
         ts.assertValueCount(2000);
     }
-    
+
     @Test
     public void testReentrantWork() {
         final PublishSubject<Integer> subject = PublishSubject.create();
-        
+
         final AtomicBoolean once = new AtomicBoolean();
-        
+
         subject.concatMapEager(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t) {
@@ -371,20 +371,20 @@ public void call(Integer t) {
             }
         })
         .subscribe(ts);
-        
+
         subject.onNext(1);
-        
+
         ts.assertNoErrors();
         ts.assertNotCompleted();
         ts.assertValues(1, 2);
     }
-    
+
     @Test
     public void testPrefetchIsBounded() {
         final AtomicInteger count = new AtomicInteger();
-        
+
         TestSubscriber<Object> ts = TestSubscriber.create(0);
-        
+
         Observable.just(1).concatMapEager(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t) {
@@ -397,13 +397,13 @@ public void call(Integer t) {
                         });
             }
         }).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertNoValues();
         ts.assertNotCompleted();
         Assert.assertEquals(RxRingBuffer.SIZE, count.get());
     }
-    
+
     @Test
     public void testInnerNull() {
         Observable.just(1).concatMapEager(new Func1<Integer, Observable<Integer>>() {
@@ -440,32 +440,32 @@ public void call(Long reqCount) {
         Assert.assertEquals(1, (long) requests.get(4));
         Assert.assertEquals(1, (long) requests.get(5));
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void many() throws Exception {
         for (int i = 2; i < 10; i++) {
             Class<?>[] clazz = new Class[i];
             Arrays.fill(clazz, Observable.class);
-            
+
             Observable<Integer>[] obs = new Observable[i];
             Arrays.fill(obs, Observable.just(1));
-            
+
             Integer[] expected = new Integer[i];
             Arrays.fill(expected, 1);
-            
+
             Method m = Observable.class.getMethod("concatEager", clazz);
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             ((Observable<Integer>)m.invoke(null, (Object[])obs)).subscribe(ts);
-            
+
             ts.assertValues(expected);
             ts.assertNoErrors();
             ts.assertCompleted();
         }
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void capacityHint() {
@@ -473,7 +473,7 @@ public void capacityHint() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
 
         Observable.concatEager(Arrays.asList(source, source, source), 1).subscribe(ts);
-        
+
         ts.assertValues(1, 1, 1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -485,19 +485,19 @@ public void observable() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
 
         Observable.concatEager(Observable.just(source, source, source)).subscribe(ts);
-        
+
         ts.assertValues(1, 1, 1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void observableCapacityHint() {
         Observable<Integer> source = Observable.just(1);
         TestSubscriber<Integer> ts = TestSubscriber.create();
 
         Observable.concatEager(Observable.just(source, source, source), 1).subscribe(ts);
-        
+
         ts.assertValues(1, 1, 1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -512,7 +512,7 @@ public void badCapacityHint() throws Exception {
         } catch (IllegalArgumentException ex) {
             assertEquals("capacityHint > 0 required but it was -99", ex.getMessage());
         }
-        
+
     }
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
@@ -524,7 +524,7 @@ public void mappingBadCapacityHint() throws Exception {
         } catch (IllegalArgumentException ex) {
             assertEquals("capacityHint > 0 required but it was -99", ex.getMessage());
         }
-        
+
     }
 
 }
diff --git a/src/test/java/rx/internal/operators/OperatorElementAtTest.java b/src/test/java/rx/internal/operators/OperatorElementAtTest.java
index b248da2797..49aa4d6f5f 100644
--- a/src/test/java/rx/internal/operators/OperatorElementAtTest.java
+++ b/src/test/java/rx/internal/operators/OperatorElementAtTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/OperatorFirstTest.java b/src/test/java/rx/internal/operators/OperatorFirstTest.java
index c3b6d32263..2d6d20d031 100644
--- a/src/test/java/rx/internal/operators/OperatorFirstTest.java
+++ b/src/test/java/rx/internal/operators/OperatorFirstTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/OperatorFlatMapTest.java b/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
index 2fa04b5c89..61805d7372 100644
--- a/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
+++ b/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -207,7 +207,7 @@ public void testFlatMapTransformsException() {
                 Observable.from(Arrays.asList(10, 20, 30)),
                 Observable.<Integer> error(new RuntimeException("Forced failure!"))
                 );
-        
+
 
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
@@ -342,11 +342,11 @@ public Observable<Integer> call(Integer t1) {
                         .subscribeOn(Schedulers.computation());
             }
         }, m);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.subscribe(ts);
-        
+
         ts.awaitTerminalEvent();
         ts.assertNoErrors();
         Set<Integer> expected = new HashSet<Integer>(Arrays.asList(
@@ -371,22 +371,22 @@ public Integer call(Integer t1, Integer t2) {
                 return t1 * 1000 + t2;
             }
         }, m);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.subscribe(ts);
-        
+
         ts.awaitTerminalEvent();
         ts.assertNoErrors();
         Set<Integer> expected = new HashSet<Integer>(Arrays.asList(
-                1010, 1011, 2020, 2021, 3030, 3031, 4040, 4041, 5050, 5051, 
+                1010, 1011, 2020, 2021, 3030, 3031, 4040, 4041, 5050, 5051,
                 6060, 6061, 7070, 7071, 8080, 8081, 9090, 9091, 10100, 10101
         ));
         Assert.assertEquals(expected.size(), ts.getOnNextEvents().size());
         System.out.println("--> testFlatMapSelectorMaxConcurrent: " + ts.getOnNextEvents());
         Assert.assertTrue(expected.containsAll(ts.getOnNextEvents()));
     }
-    
+
     @Test
     public void testFlatMapTransformsMaxConcurrentNormalLoop() {
         for (int i = 0; i < 1000; i++) {
@@ -396,12 +396,12 @@ public void testFlatMapTransformsMaxConcurrentNormalLoop() {
             testFlatMapTransformsMaxConcurrentNormal();
         }
     }
-    
+
     @Test
     public void testFlatMapTransformsMaxConcurrentNormal() {
         final int m = 2;
         final AtomicInteger subscriptionCount = new AtomicInteger();
-        Observable<Integer> onNext = 
+        Observable<Integer> onNext =
                 compose(Observable.from(Arrays.asList(1, 2, 3)).observeOn(Schedulers.computation()), subscriptionCount, m)
                 .subscribeOn(Schedulers.computation());
         Observable<Integer> onCompleted = compose(Observable.from(Arrays.asList(4)), subscriptionCount, m)
@@ -415,7 +415,7 @@ public void testFlatMapTransformsMaxConcurrentNormal() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>(o);
 
         source.flatMap(just(onNext), just(onError), just0(onCompleted), m).subscribe(ts);
-        
+
         ts.awaitTerminalEvent(1, TimeUnit.SECONDS);
         ts.assertNoErrors();
         ts.assertTerminalEvent();
@@ -429,7 +429,7 @@ public void testFlatMapTransformsMaxConcurrentNormal() {
         verify(o, never()).onNext(5);
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Ignore("Don't care for any reordering")
     @Test(timeout = 10000)
     public void flatMapRangeAsyncLoop() {
@@ -508,19 +508,19 @@ public Observable<Integer> call(Integer t) {
             assertEquals(1000, list.size());
         }
     }
-    
+
     @Test
     public void flatMapIntPassthruAsync() {
         for (int i = 0;i < 1000; i++) {
             TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-            
+
             Observable.range(1, 1000).flatMap(new Func1<Integer, Observable<Integer>>() {
                 @Override
                 public Observable<Integer> call(Integer t) {
                     return Observable.just(1).subscribeOn(Schedulers.computation());
                 }
             }).subscribe(ts);
-            
+
             ts.awaitTerminalEvent(5, TimeUnit.SECONDS);
             ts.assertNoErrors();
             ts.assertCompleted();
@@ -531,25 +531,25 @@ public Observable<Integer> call(Integer t) {
     public void flatMapTwoNestedSync() {
         for (final int n : new int[] { 1, 1000, 1000000 }) {
             TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-    
+
             Observable.just(1, 2).flatMap(new Func1<Integer, Observable<Integer>>() {
                 @Override
                 public Observable<Integer> call(Integer t) {
                     return Observable.range(1, n);
                 }
             }).subscribe(ts);
-            
+
             System.out.println("flatMapTwoNestedSync >> @ " + n);
             ts.assertNoErrors();
             ts.assertCompleted();
             ts.assertValueCount(n * 2);
         }
     }
-    
+
     @Test
     public void justEmptyMixture() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(0, 4 * RxRingBuffer.SIZE)
         .flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
@@ -558,15 +558,15 @@ public Observable<Integer> call(Integer v) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValueCount(2 * RxRingBuffer.SIZE);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         int j = 1;
         for (Integer v : ts.getOnNextEvents()) {
             Assert.assertEquals(j, v.intValue());
-            
+
             j += 2;
         }
     }
@@ -574,7 +574,7 @@ public Observable<Integer> call(Integer v) {
     @Test
     public void rangeEmptyMixture() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(0, 4 * RxRingBuffer.SIZE)
         .flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
@@ -583,17 +583,17 @@ public Observable<Integer> call(Integer v) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValueCount(4 * RxRingBuffer.SIZE);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         int j = 1;
         List<Integer> list = ts.getOnNextEvents();
         for (int i = 0; i < list.size(); i += 2) {
             Assert.assertEquals(j, list.get(i).intValue());
             Assert.assertEquals(j + 1, list.get(i + 1).intValue());
-            
+
             j += 2;
         }
     }
@@ -601,7 +601,7 @@ public Observable<Integer> call(Integer v) {
     @Test
     public void justEmptyMixtureMaxConcurrent() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(0, 4 * RxRingBuffer.SIZE)
         .flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
@@ -610,15 +610,15 @@ public Observable<Integer> call(Integer v) {
             }
         }, 16)
         .subscribe(ts);
-        
+
         ts.assertValueCount(2 * RxRingBuffer.SIZE);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         int j = 1;
         for (Integer v : ts.getOnNextEvents()) {
             Assert.assertEquals(j, v.intValue());
-            
+
             j += 2;
         }
     }
@@ -626,7 +626,7 @@ public Observable<Integer> call(Integer v) {
     @Test
     public void rangeEmptyMixtureMaxConcurrent() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(0, 4 * RxRingBuffer.SIZE)
         .flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
@@ -635,17 +635,17 @@ public Observable<Integer> call(Integer v) {
             }
         }, 16)
         .subscribe(ts);
-        
+
         ts.assertValueCount(4 * RxRingBuffer.SIZE);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         int j = 1;
         List<Integer> list = ts.getOnNextEvents();
         for (int i = 0; i < list.size(); i += 2) {
             Assert.assertEquals(j, list.get(i).intValue());
             Assert.assertEquals(j + 1, list.get(i + 1).intValue());
-            
+
             j += 2;
         }
     }
diff --git a/src/test/java/rx/internal/operators/OperatorGroupByTest.java b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
index c137bcc8f2..2b9328795d 100644
--- a/src/test/java/rx/internal/operators/OperatorGroupByTest.java
+++ b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -176,7 +176,7 @@ public void call(V v) {
 
     /**
      * Assert that only a single subscription to a stream occurs and that all events are received.
-     * 
+     *
      * @throws Throwable
      */
     @Test
@@ -1119,7 +1119,7 @@ public void normalBehavior() {
          * baR bar BAR
          * Baz baz bAZ
          * qux
-         * 
+         *
          */
         Func1<String, String> keysel = new Func1<String, String>() {
             @Override
@@ -1439,7 +1439,7 @@ public Integer call(Integer i) {
         assertEquals(Arrays.asList(e), inner1.getOnErrorEvents());
         assertEquals(Arrays.asList(e), inner2.getOnErrorEvents());
     }
-    
+
     @Test
     public void testRequestOverflow() {
         final AtomicBoolean completed = new AtomicBoolean(false);
@@ -1460,7 +1460,7 @@ public Observable<Integer> call(GroupedObservable<Integer, Integer> g) {
                     }
                 })
                 .subscribe(new Subscriber<Integer>() {
-                    
+
                     @Override
                     public void onStart() {
                         request(2);
@@ -1469,12 +1469,12 @@ public void onStart() {
                     @Override
                     public void onCompleted() {
                         completed.set(true);
-                        
+
                     }
 
                     @Override
                     public void onError(Throwable e) {
-                        
+
                     }
 
                     @Override
@@ -1485,10 +1485,10 @@ public void onNext(Integer t) {
                     }});
         assertTrue(completed.get());
     }
-    
+
     /**
      * Issue #3425.
-     * 
+     *
      * The problem is that a request of 1 may create a new group, emit to the desired group
      * or emit to a completely different group. In this test, the merge requests N which
      * must be produced by the range, however it will create a bunch of groups before the actual
@@ -1509,14 +1509,14 @@ public Object call(Integer i) {
             ).toBlocking().last();
         }
     }
-    
+
     /**
      * Synchronous verification of issue #3425.
      */
     @Test
     public void testBackpressureInnerDoesntOverflowOuter() {
         TestSubscriber<Object> ts = TestSubscriber.create(0);
-        
+
         Observable.just(1, 2)
                 .groupBy(new Func1<Integer, Object>() {
                     @Override
@@ -1535,17 +1535,17 @@ public void call(GroupedObservable<Object, Integer> g) {
                 .subscribe(ts)
                 ;
         ts.requestMore(1);
-        
+
         ts.assertNotCompleted();
         ts.assertNoErrors();
         ts.assertValueCount(1);
     }
-    
+
     @Test
     public void testOneGroupInnerRequestsTwiceBuffer() {
         TestSubscriber<Object> ts1 = TestSubscriber.create(0);
         final TestSubscriber<Object> ts2 = TestSubscriber.create(0);
-        
+
         Observable.range(1, RxRingBuffer.SIZE * 2)
         .groupBy(new Func1<Integer, Object>() {
             @Override
@@ -1560,27 +1560,27 @@ public void call(GroupedObservable<Object, Integer> g) {
             }
         })
         .subscribe(ts1);
-        
+
         ts1.assertNoValues();
         ts1.assertNoErrors();
         ts1.assertNotCompleted();
-        
+
         ts2.assertNoValues();
         ts2.assertNoErrors();
         ts2.assertNotCompleted();
-        
+
         ts1.requestMore(1);
-        
+
         ts1.assertValueCount(1);
         ts1.assertNoErrors();
         ts1.assertNotCompleted();
-        
+
         ts2.assertNoValues();
         ts2.assertNoErrors();
         ts2.assertNotCompleted();
-        
+
         ts2.requestMore(RxRingBuffer.SIZE * 2);
-        
+
         ts2.assertValueCount(RxRingBuffer.SIZE * 2);
         ts2.assertNoErrors();
         ts2.assertNotCompleted();
@@ -1809,7 +1809,7 @@ public Integer call(Integer pair) {
         outer.assertValueCount(2);
 
     }
-    
+
     @Test
     public void mapFactoryEvictionWorks() {
         Func1<Integer, Integer> keySelector = new Func1<Integer, Integer> (){
@@ -1819,20 +1819,20 @@ public Integer call(Integer t) {
             }};
         Func1<Integer, Integer> elementSelector = UtilityFunctions.identity();
         final List<Integer> evictedKeys = new ArrayList<Integer>();
-        //normally would use Guava CacheBuilder or similar but for a bit more 
+        //normally would use Guava CacheBuilder or similar but for a bit more
         //control make something custom
         Func1<Action1<Integer>, Map<Integer, Object>> mapFactory = new Func1<Action1<Integer>, Map<Integer, Object>>() {
             @Override
             public Map<Integer, Object> call(final Action1<Integer> evicted) {
-                // is a bit risky to override the put method because 
+                // is a bit risky to override the put method because
                 // of possible side-effects (e.g. remove could call put and we did not know it)
                 // to fix just need to use composition but needs a verbose implementation of Map
                 // interface
                 return new ConcurrentHashMap<Integer,Object>() {
                     private static final long serialVersionUID = -7519109652858021153L;
-                    
+
                     Integer lastKey = null;
-                    
+
                     @Override
                     public Object put(Integer key, Object value) {
                         if (this.size() >= 5) {
@@ -1873,15 +1873,15 @@ public String call(Integer x) {
                 .toList().toBlocking().single();
         assertEquals(expected, ts.getOnNextEvents());
     }
-    
+
     private static final Func1<Integer, Integer> EVICTING_MAP_ELEMENT_SELECTOR = UtilityFunctions.identity();
-    
+
     private static final Func1<Integer, Integer> EVICTING_MAP_KEY_SELECTOR = new Func1<Integer, Integer> (){
         @Override
         public Integer call(Integer t) {
             return t /10;
         }};
-    
+
     @Test
     public void testEvictingMapFactoryIfMapPutThrowsRuntimeExceptionThenErrorEmittedByStream() {
         final RuntimeException exception = new RuntimeException("boo");
@@ -1894,7 +1894,7 @@ public void testEvictingMapFactoryIfMapPutThrowsRuntimeExceptionThenErrorEmitted
             .subscribe(ts);
         ts.assertError(exception);
     }
-    
+
     @Test(expected = OnErrorNotImplementedException.class)
     public void testEvictingMapFactoryIfMapPutThrowsFatalErrorThenErrorThrownBySubscribe() {
         final RuntimeException exception = new OnErrorNotImplementedException("boo", new RuntimeException());
@@ -1913,19 +1913,19 @@ private static Func1<Action1<Integer>, Map<Integer, Object>> createMapFactoryTha
             @SuppressWarnings("serial")
             @Override
             public Map<Integer, Object> call(final Action1<Integer> evicted) {
-                // is a bit risky to override the put method because 
+                // is a bit risky to override the put method because
                 // of possible side-effects (e.g. remove could call put and we did not know it)
                 // to fix just need to use composition but needs a verbose implementation of Map
                 // interface
                 return new ConcurrentHashMap<Integer,Object>() {
-                    
+
                     @Override
                     public Object put(Integer key, Object value) {
                         throw exception;
                     }};
             }};
     }
-    
+
     @Test
     public void mapFactoryEvictionWorksWithGuavaCache() {
         final List<Integer> evictedKeys = new ArrayList<Integer>();
@@ -1939,7 +1939,7 @@ public Map<Integer, Object> call(final Action1<Integer> action) {
                             @Override
                             public void onRemoval(RemovalNotification<Integer, Object> notification) {
                                 action.call(notification.getKey());
-                                evictedKeys.add(notification.getKey());                            
+                                evictedKeys.add(notification.getKey());
                             }
                         })
                         .build().asMap();
@@ -1975,14 +1975,14 @@ public String call(Integer x) {
                 .toList().toBlocking().single();
         assertEquals(expected, ts.getOnNextEvents());
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void testGroupByThrowsNpeIfEvictingMapFactoryNull() {
         Observable
         .range(1, 100)
         .groupBy(EVICTING_MAP_KEY_SELECTOR, EVICTING_MAP_ELEMENT_SELECTOR, null);
     }
-    
+
     @Test
     public void testEvictingMapFactoryIfMapCreateThrowsRuntimeExceptionThenErrorEmittedByStream() {
         final RuntimeException exception = new RuntimeException("boo");
@@ -1995,7 +1995,7 @@ public void testEvictingMapFactoryIfMapCreateThrowsRuntimeExceptionThenErrorEmit
             .subscribe(ts);
         ts.assertError(exception);
     }
-    
+
     @Test(expected=OnErrorNotImplementedException.class)
     public void testEvictingMapFactoryIfMapCreateThrowsFatalErrorThenSubscribeThrows() {
         final OnErrorNotImplementedException exception = new OnErrorNotImplementedException("boo", new RuntimeException());
diff --git a/src/test/java/rx/internal/operators/OperatorIgnoreElementsTest.java b/src/test/java/rx/internal/operators/OperatorIgnoreElementsTest.java
index 92424da031..832237496f 100644
--- a/src/test/java/rx/internal/operators/OperatorIgnoreElementsTest.java
+++ b/src/test/java/rx/internal/operators/OperatorIgnoreElementsTest.java
@@ -59,7 +59,7 @@ public void call(Integer t) {
         assertEquals(num, upstreamCount.get());
         assertEquals(0, count);
     }
-    
+
     @Test
     public void testCompletedOk() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
@@ -69,7 +69,7 @@ public void testCompletedOk() {
         ts.assertTerminalEvent();
         ts.assertUnsubscribed();
     }
-    
+
     @Test
     public void testErrorReceived() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
@@ -81,7 +81,7 @@ public void testErrorReceived() {
         assertEquals(1, ts.getOnErrorEvents().size());
         assertEquals("boo", ts.getOnErrorEvents().get(0).getMessage());
     }
-    
+
     @Test
     public void testUnsubscribesFromUpstream() {
         final AtomicBoolean unsub = new AtomicBoolean();
@@ -142,5 +142,5 @@ public void onNext(Integer t) {
         assertEquals(num, upstreamCount.get());
         assertEquals(0, count.get());
     }
-    
+
 }
diff --git a/src/test/java/rx/internal/operators/OperatorLastTest.java b/src/test/java/rx/internal/operators/OperatorLastTest.java
index 48d866e338..1b5638eb08 100644
--- a/src/test/java/rx/internal/operators/OperatorLastTest.java
+++ b/src/test/java/rx/internal/operators/OperatorLastTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/OperatorMapNotificationTest.java b/src/test/java/rx/internal/operators/OperatorMapNotificationTest.java
index cd58bb2004..c8b0a11581 100644
--- a/src/test/java/rx/internal/operators/OperatorMapNotificationTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMapNotificationTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -48,12 +48,12 @@ public Observable<Object> call() {
                     }
                 }
         ).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertNotCompleted();
         ts.assertValue(2);
     }
-    
+
     @Test
     public void backpressure() {
         TestSubscriber<Object> ts = TestSubscriber.create(0L);
@@ -78,19 +78,19 @@ public Integer call() {
                     }
                 }
         )).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(3);
-        
+
         ts.assertValues(2, 3, 4);
         ts.assertNoErrors();
         ts.assertNotCompleted();
 
         ts.requestMore(1);
-        
+
         ts.assertValues(2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -101,7 +101,7 @@ public void noBackpressure() {
         TestSubscriber<Object> ts = TestSubscriber.create(0L);
 
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps.lift(new OperatorMapNotification<Integer, Integer>(
                 new Func1<Integer, Integer>() {
                     @Override
@@ -122,26 +122,26 @@ public Integer call() {
                     }
                 }
         )).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ps.onNext(1);
         ps.onNext(2);
         ps.onNext(3);
         ps.onCompleted();
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue(0);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
     }
 
 }
diff --git a/src/test/java/rx/internal/operators/OperatorMapPairTest.java b/src/test/java/rx/internal/operators/OperatorMapPairTest.java
index 7460496525..3217f05f0e 100644
--- a/src/test/java/rx/internal/operators/OperatorMapPairTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMapPairTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -26,11 +26,11 @@
 public class OperatorMapPairTest {
     @Test
     public void castCrashUnsubscribes() {
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         ps.flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t) {
@@ -42,13 +42,13 @@ public Integer call(Integer t1, Integer t2) {
                 return t1;
             }
         }).unsafeSubscribe(ts);
-        
+
         Assert.assertTrue("Not subscribed?", ps.hasObservers());
-        
+
         ps.onNext(1);
-        
+
         Assert.assertFalse("Subscribed?", ps.hasObservers());
-        
+
         ts.assertError(TestException.class);
     }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorMaterializeTest.java b/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
index 06f231cf90..1ddaa6c45d 100644
--- a/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -124,7 +124,7 @@ public void testBackpressureNoError() {
         ts.assertValueCount(4);
         ts.assertCompleted();
     }
-    
+
     @Test
     public void testBackpressureNoErrorAsync() throws InterruptedException {
         TestSubscriber<Notification<Integer>> ts = TestSubscriber.create(0);
@@ -187,7 +187,7 @@ public void call(Object t) {
         ts.assertNoValues();
         ts.assertTerminalEvent();
     }
-    
+
     @Test
     public void testUnsubscribeJustBeforeCompletionNotificationShouldPreventThatNotificationArriving() {
         TestSubscriber<Notification<Integer>> ts = TestSubscriber.create(0);
diff --git a/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java b/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java
index 2468eb7b0a..7943e30dee 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -275,7 +275,7 @@ public void testMergeList() {
     }
 
     // This is pretty much a clone of testMergeList but with the overloaded MergeDelayError for Iterables
-    @Test     
+    @Test
     public void mergeIterable() {
         final Observable<String> o1 = Observable.create(new TestSynchronousObservable());
         final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
@@ -288,7 +288,7 @@ public void mergeIterable() {
 
         verify(stringObserver, never()).onError(any(Throwable.class));
         verify(stringObserver, times(1)).onCompleted();
-        verify(stringObserver, times(2)).onNext("hello");	
+        verify(stringObserver, times(2)).onNext("hello");
     }
 
     @Test
@@ -461,19 +461,19 @@ public void call(Subscriber<? super Integer> t1) {
                 try {
                     t1.onNext(0);
                 } catch (Throwable swallow) {
-                    
+
                 }
                 t1.onNext(1);
                 t1.onCompleted();
             }
         });
-        
+
         Observable<Integer> result = Observable.mergeDelayError(source, Observable.just(2));
-        
+
         @SuppressWarnings("unchecked")
         final Observer<Integer> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         result.unsafeSubscribe(new Subscriber<Integer>() {
             int calls;
             @Override
@@ -493,9 +493,9 @@ public void onError(Throwable e) {
             public void onCompleted() {
                 o.onCompleted();
             }
-            
+
         });
-        
+
         /*
          * If the child onNext throws, why would we keep accepting values from
          * other sources?
@@ -535,17 +535,17 @@ public void call(Subscriber<? super Observable<String>> op) {
                     op.onError(new NullPointerException("throwing exception in parent"));
                 }
             });
-    
+
             @SuppressWarnings("unchecked")
             Observer<String> stringObserver = mock(Observer.class);
-            
+
             TestSubscriber<String> ts = new TestSubscriber<String>(stringObserver);
             Observable<String> m = Observable.mergeDelayError(parentObservable);
             m.subscribe(ts);
             System.out.println("testErrorInParentObservableDelayed | " + i);
             ts.awaitTerminalEvent(2000, TimeUnit.MILLISECONDS);
             ts.assertTerminalEvent();
-    
+
             verify(stringObserver, times(2)).onNext("hello");
             verify(stringObserver, times(1)).onError(any(NullPointerException.class));
             verify(stringObserver, never()).onCompleted();
@@ -578,25 +578,25 @@ public void run() {
     public void testDelayErrorMaxConcurrent() {
         final List<Long> requests = new ArrayList<Long>();
         Observable<Integer> source = Observable.mergeDelayError(Observable.just(
-                Observable.just(1).asObservable(), 
+                Observable.just(1).asObservable(),
                 Observable.<Integer>error(new TestException())).doOnRequest(new Action1<Long>() {
                     @Override
                     public void call(Long t1) {
                         requests.add(t1);
                     }
                 }), 1);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.subscribe(ts);
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1));
         ts.assertTerminalEvent();
         assertEquals(1, ts.getOnErrorEvents().size());
         assertTrue(ts.getOnErrorEvents().get(0) instanceof TestException);
         assertEquals(Arrays.asList(1L, 1L, 1L), requests);
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void iterableMaxConcurrent() {
@@ -604,15 +604,15 @@ public void iterableMaxConcurrent() {
 
         PublishSubject<Integer> ps1 = PublishSubject.create();
         PublishSubject<Integer> ps2 = PublishSubject.create();
-        
+
         Observable.mergeDelayError(Arrays.asList(ps1, ps2), 1).subscribe(ts);
-        
+
         assertTrue("ps1 has no subscribers?!", ps1.hasObservers());
         assertFalse("ps2 has subscribers?!", ps2.hasObservers());
-        
+
         ps1.onNext(1);
         ps1.onCompleted();
-        
+
         assertFalse("ps1 has subscribers?!", ps1.hasObservers());
         assertTrue("ps2 has no subscribers?!", ps2.hasObservers());
 
@@ -623,7 +623,7 @@ public void iterableMaxConcurrent() {
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void iterableMaxConcurrentError() {
@@ -631,15 +631,15 @@ public void iterableMaxConcurrentError() {
 
         PublishSubject<Integer> ps1 = PublishSubject.create();
         PublishSubject<Integer> ps2 = PublishSubject.create();
-        
+
         Observable.mergeDelayError(Arrays.asList(ps1, ps2), 1).subscribe(ts);
-        
+
         assertTrue("ps1 has no subscribers?!", ps1.hasObservers());
         assertFalse("ps2 has subscribers?!", ps2.hasObservers());
-        
+
         ps1.onNext(1);
         ps1.onError(new TestException());
-        
+
         assertFalse("ps1 has subscribers?!", ps1.hasObservers());
         assertTrue("ps2 has no subscribers?!", ps2.hasObservers());
 
@@ -649,31 +649,31 @@ public void iterableMaxConcurrentError() {
         ts.assertValues(1, 2);
         ts.assertError(CompositeException.class);
         ts.assertNotCompleted();
-        
+
         CompositeException ce = (CompositeException)ts.getOnErrorEvents().get(0);
-        
+
         assertEquals(2, ce.getExceptions().size());
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void mergeMany() throws Exception {
         for (int i = 2; i < 10; i++) {
             Class<?>[] clazz = new Class[i];
             Arrays.fill(clazz, Observable.class);
-            
+
             Observable<Integer>[] obs = new Observable[i];
             Arrays.fill(obs, Observable.just(1));
-            
+
             Integer[] expected = new Integer[i];
             Arrays.fill(expected, 1);
-            
+
             Method m = Observable.class.getMethod("mergeDelayError", clazz);
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             ((Observable<Integer>)m.invoke(null, (Object[])obs)).subscribe(ts);
-            
+
             ts.assertValues(expected);
             ts.assertNoErrors();
             ts.assertCompleted();
@@ -690,27 +690,27 @@ public void mergeManyError() throws Exception {
         for (int i = 2; i < 10; i++) {
             Class<?>[] clazz = new Class[i];
             Arrays.fill(clazz, Observable.class);
-            
+
             Observable<Integer>[] obs = new Observable[i];
             for (int j = 0; j < i; j++) {
                 obs[j] = withError(Observable.just(1));
             }
-            
+
             Integer[] expected = new Integer[i];
             Arrays.fill(expected, 1);
-            
+
             Method m = Observable.class.getMethod("mergeDelayError", clazz);
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             ((Observable<Integer>)m.invoke(null, (Object[])obs)).subscribe(ts);
-            
+
             ts.assertValues(expected);
             ts.assertError(CompositeException.class);
             ts.assertNotCompleted();
-            
+
             CompositeException ce = (CompositeException)ts.getOnErrorEvents().get(0);
-            
+
             assertEquals(i, ce.getExceptions().size());
         }
     }
diff --git a/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java b/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
index f383853f6f..56aa690b84 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -123,7 +123,7 @@ public void run() {
         }
 
     }
-    
+
     @Test
     public void testMergeALotOfSourcesOneByOneSynchronously() {
         int n = 10000;
@@ -154,7 +154,7 @@ public void testMergeALotOfSourcesOneByOneSynchronouslyTakeHalf() {
         }
         assertEquals(j, n / 2);
     }
-    
+
     @Test
     public void testSimple() {
         for (int i = 1; i < 100; i++) {
@@ -165,9 +165,9 @@ public void testSimple() {
                 sourceList.add(Observable.just(j));
                 result.add(j);
             }
-            
+
             Observable.merge(sourceList, i).subscribe(ts);
-        
+
             ts.assertNoErrors();
             ts.assertTerminalEvent();
             ts.assertReceivedOnNext(result);
@@ -183,9 +183,9 @@ public void testSimpleOneLess() {
                 sourceList.add(Observable.just(j));
                 result.add(j);
             }
-            
+
             Observable.merge(sourceList, i - 1).subscribe(ts);
-        
+
             ts.assertNoErrors();
             ts.assertTerminalEvent();
             ts.assertReceivedOnNext(result);
@@ -207,13 +207,13 @@ public void testSimpleAsync() {
                 sourceList.add(Observable.just(j).subscribeOn(Schedulers.io()));
                 expected.add(j);
             }
-            
+
             Observable.merge(sourceList, i).subscribe(ts);
-        
+
             ts.awaitTerminalEvent(1, TimeUnit.SECONDS);
             ts.assertNoErrors();
             Set<Integer> actual = new HashSet<Integer>(ts.getOnNextEvents());
-            
+
             assertEquals(expected, actual);
         }
     }
@@ -241,26 +241,26 @@ public void testSimpleOneLessAsync() {
                 sourceList.add(Observable.just(j).subscribeOn(Schedulers.io()));
                 expected.add(j);
             }
-            
+
             Observable.merge(sourceList, i - 1).subscribe(ts);
-        
+
             ts.awaitTerminalEvent(1, TimeUnit.SECONDS);
             ts.assertNoErrors();
             Set<Integer> actual = new HashSet<Integer>(ts.getOnNextEvents());
-            
+
             assertEquals(expected, actual);
         }
     }
     @Test(timeout = 5000)
     public void testBackpressureHonored() throws Exception {
         List<Observable<Integer>> sourceList = new ArrayList<Observable<Integer>>(3);
-        
+
         sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io()));
         sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io()));
         sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io()));
-        
+
         final CountDownLatch cdl = new CountDownLatch(5);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onStart() {
@@ -272,31 +272,31 @@ public void onNext(Integer t) {
                 cdl.countDown();
             }
         };
-        
+
         Observable.merge(sourceList, 2).subscribe(ts);
-        
+
         ts.requestMore(5);
-        
+
         cdl.await();
-        
+
         ts.assertNoErrors();
         assertEquals(5, ts.getOnNextEvents().size());
         assertEquals(0, ts.getCompletions());
-        
+
         ts.unsubscribe();
     }
     @Test(timeout = 5000)
     public void testTake() throws Exception {
         List<Observable<Integer>> sourceList = new ArrayList<Observable<Integer>>(3);
-        
+
         sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io()));
         sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io()));
         sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io()));
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.merge(sourceList, 2).take(5).subscribe(ts);
-        
+
         ts.awaitTerminalEvent();
         ts.assertNoErrors();
         assertEquals(5, ts.getOnNextEvents().size());
diff --git a/src/test/java/rx/internal/operators/OperatorMergeTest.java b/src/test/java/rx/internal/operators/OperatorMergeTest.java
index 76c7b43333..746f794158 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -621,7 +621,7 @@ public void testBackpressureUpstream2InLoop() throws InterruptedException {
             testBackpressureUpstream2();
         }
     }
-    
+
     @Test
     public void testBackpressureUpstream2() throws InterruptedException {
         final AtomicInteger generated1 = new AtomicInteger();
@@ -636,9 +636,9 @@ public void onNext(Integer t) {
 
         Observable.merge(o1.take(RxRingBuffer.SIZE * 2), Observable.just(-99)).subscribe(testSubscriber);
         testSubscriber.awaitTerminalEvent();
-        
+
         List<Integer> onNextEvents = testSubscriber.getOnNextEvents();
-        
+
         System.out.println("Generated 1: " + generated1.get() + " / received: " + onNextEvents.size());
         System.out.println(onNextEvents);
 
@@ -653,7 +653,7 @@ public void onNext(Integer t) {
 
     /**
      * This is the same as the upstreams ones, but now adds the downstream as well by using observeOn.
-     * 
+     *
      * This requires merge to also obey the Product.request values coming from it's child subscriber.
      * @throws InterruptedException if the wait is interrupted
      */
@@ -737,13 +737,13 @@ public void onNext(Integer t) {
     /**
      * Currently there is no solution to this ... we can't exert backpressure on the outer Observable if we
      * can't know if the ones we've received so far are going to emit or not, otherwise we could starve the system.
-     * 
+     *
      * For example, 10,000 Observables are being merged (bad use case to begin with, but ...) and it's only one of them
      * that will ever emit. If backpressure only allowed the first 1,000 to be sent, we would hang and never receive an event.
-     * 
+     *
      * Thus, we must allow all Observables to be sent. The ScalarSynchronousObservable use case is an exception to this since
      * we can grab the value synchronously.
-     * 
+     *
      * @throws InterruptedException
      */
     @Test(timeout = 5000)
@@ -1110,7 +1110,7 @@ public void shouldNotReceivedDelayedErrorWhileThereAreStillNormalEmissionsInTheQ
         subscriber.assertReceivedOnNext(asList(1, 2, 3, 4));
         assertEquals(asList(exception), subscriber.getOnErrorEvents());
     }
-    
+
     @Test
     public void testMergeKeepsRequesting() throws InterruptedException {
         //for (int i = 0; i < 5000; i++) {
@@ -1169,7 +1169,7 @@ public void call() {
             assertTrue(a);
         //}
     }
-    
+
     @Test
     public void testMergeRequestOverflow() throws InterruptedException {
         //do a non-trivial merge so that future optimisations with EMPTY don't invalidate this test
@@ -1177,7 +1177,7 @@ public void testMergeRequestOverflow() throws InterruptedException {
         final int expectedCount = 4;
         final CountDownLatch latch = new CountDownLatch(expectedCount);
         o.subscribeOn(Schedulers.computation()).subscribe(new Subscriber<Integer>() {
-            
+
             @Override
             public void onStart() {
                 request(1);
@@ -1226,7 +1226,7 @@ public void call(Integer s) {
             }
         };
     }
-    
+
     Func1<Integer, Observable<Integer>> toScalar = new Func1<Integer, Observable<Integer>>() {
         @Override
         public Observable<Integer> call(Integer t) {
@@ -1239,7 +1239,7 @@ public Observable<Integer> call(Integer t) {
             return Observable.just(t).asObservable();
         }
     };
-    
+
     void runMerge(Func1<Integer, Observable<Integer>> func, TestSubscriber<Integer> ts) {
         List<Integer> list = new ArrayList<Integer>();
         for (int i = 0; i < 1000; i++) {
@@ -1247,16 +1247,16 @@ void runMerge(Func1<Integer, Observable<Integer>> func, TestSubscriber<Integer>
         }
         Observable<Integer> source = Observable.from(list);
         source.flatMap(func).subscribe(ts);
-        
+
         if (ts.getOnNextEvents().size() != 1000) {
             System.out.println(ts.getOnNextEvents());
         }
-        
+
         ts.assertTerminalEvent();
         ts.assertNoErrors();
         ts.assertReceivedOnNext(list);
     }
-    
+
     @Test
     public void testFastMergeFullScalar() {
         runMerge(toScalar, new TestSubscriber<Integer>());
@@ -1307,14 +1307,14 @@ public void onNext(Integer t) {
             runMerge(toHiddenScalar, ts);
         }
     }
-    
+
     @Test
     public void testUnboundedDefaultConcurrency() {
         List<Observable<Integer>> os = new ArrayList<Observable<Integer>>();
         for(int i=0; i < 2000; i++) {
             os.add(Observable.<Integer>never());
         }
-        os.add(Observable.range(0, 100));       
+        os.add(Observable.range(0, 100));
 
         TestSubscriber<Integer> ts = TestSubscriber.create();
         Observable.merge(os).take(1).subscribe(ts);
@@ -1329,7 +1329,7 @@ public void testConcurrencyLimit() {
         for(int i=0; i < 2000; i++) {
             os.add(Observable.<Integer>never());
         }
-        os.add(Observable.range(0, 100));       
+        os.add(Observable.range(0, 100));
 
         TestSubscriber<Integer> ts = TestSubscriber.create();
         Observable.merge(os, Integer.MAX_VALUE).take(1).subscribe(ts);
@@ -1359,30 +1359,30 @@ public void zeroMaxConcurrent() {
             assertEquals("maxConcurrent > 0 required but it was 0", e.getMessage());
         }
     }
-    
+
     @Test
     public void mergeJustNull() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
-        
+
         Observable.range(1, 2).flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t) {
                 return Observable.just(null);
             }
         }).subscribe(ts);
-        
+
         ts.requestMore(2);
         ts.assertValues(null, null);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void mergeConcurrentJustJust() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.merge(Observable.just(Observable.just(1)), 5).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -1391,14 +1391,14 @@ public void mergeConcurrentJustJust() {
     @Test
     public void mergeConcurrentJustRange() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.merge(Observable.just(Observable.range(1, 5)), 5).subscribe(ts);
-        
+
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
 
     @SuppressWarnings("unchecked")
     @Test
@@ -1406,25 +1406,25 @@ public void mergeMany() throws Exception {
         for (int i = 2; i < 10; i++) {
             Class<?>[] clazz = new Class[i];
             Arrays.fill(clazz, Observable.class);
-            
+
             Observable<Integer>[] obs = new Observable[i];
             Arrays.fill(obs, Observable.just(1));
-            
+
             Integer[] expected = new Integer[i];
             Arrays.fill(expected, 1);
-            
+
             Method m = Observable.class.getMethod("merge", clazz);
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             ((Observable<Integer>)m.invoke(null, (Object[])obs)).subscribe(ts);
-            
+
             ts.assertValues(expected);
             ts.assertNoErrors();
             ts.assertCompleted();
         }
     }
-    
+
     @SuppressWarnings("unchecked")
     @Test
     public void mergeArrayMaxConcurrent() {
@@ -1432,15 +1432,15 @@ public void mergeArrayMaxConcurrent() {
 
         PublishSubject<Integer> ps1 = PublishSubject.create();
         PublishSubject<Integer> ps2 = PublishSubject.create();
-        
+
         Observable.merge(new Observable[] { ps1, ps2 }, 1).subscribe(ts);
-        
+
         assertTrue("ps1 has no subscribers?!", ps1.hasObservers());
         assertFalse("ps2 has subscribers?!", ps2.hasObservers());
-        
+
         ps1.onNext(1);
         ps1.onCompleted();
-        
+
         assertFalse("ps1 has subscribers?!", ps1.hasObservers());
         assertTrue("ps2 has no subscribers?!", ps2.hasObservers());
 
@@ -1451,14 +1451,14 @@ public void mergeArrayMaxConcurrent() {
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @Test
     public void flatMapJustJust() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(Observable.just(1)).flatMap((Func1)UtilityFunctions.identity()).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -1468,21 +1468,21 @@ public void flatMapJustJust() {
     @Test
     public void flatMapJustRange() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(Observable.range(1, 5)).flatMap((Func1)UtilityFunctions.identity()).subscribe(ts);
-        
+
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @Test
     public void flatMapMaxConcurrentJustJust() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(Observable.just(1)).flatMap((Func1)UtilityFunctions.identity(), 5).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -1492,14 +1492,14 @@ public void flatMapMaxConcurrentJustJust() {
     @Test
     public void flatMapMaxConcurrentJustRange() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(Observable.range(1, 5)).flatMap((Func1)UtilityFunctions.identity(), 5).subscribe(ts);
-        
+
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void noInnerReordering() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
@@ -1510,33 +1510,33 @@ public void noInnerReordering() {
         PublishSubject<Integer> ps = PublishSubject.create();
 
         ms.onNext(ps);
-        
+
         ps.onNext(1);
-        
+
         BackpressureUtils.getAndAddRequest(ms.producer, 2);
-        
+
         ps.onNext(2);
-        
+
         ms.emit();
-        
+
         ts.assertValues(1, 2);
     }
-    
+
     @Test
     public void noOuterScalarReordering() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
         MergeSubscriber<Integer> ms = new MergeSubscriber<Integer>(ts, false, 128);
         ms.producer = new MergeProducer<Integer>(ms);
         ts.setProducer(ms.producer);
-        
+
         ms.onNext(Observable.just(1));
-        
+
         BackpressureUtils.getAndAddRequest(ms.producer, 2);
-        
+
         ms.onNext(Observable.just(2));
-        
+
         ms.emit();
-        
+
         ts.assertValues(1, 2);
     }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorMulticastTest.java b/src/test/java/rx/internal/operators/OperatorMulticastTest.java
index bbde4a3751..79ca19a86c 100644
--- a/src/test/java/rx/internal/operators/OperatorMulticastTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMulticastTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -73,14 +73,14 @@ public void testMulticastConnectTwice() {
 
         Subscription sub = multicasted.connect();
         Subscription sub2 = multicasted.connect();
-        
+
         source.onNext("two");
         source.onCompleted();
 
         verify(observer, never()).onNext("one");
         verify(observer, times(1)).onNext("two");
         verify(observer, times(1)).onCompleted();
-        
+
         assertEquals(sub, sub2);
 
     }
@@ -117,13 +117,13 @@ public void testMulticastDisconnect() {
         verify(observer, times(1)).onCompleted();
 
     }
-    
+
     private static final class PublishSubjectFactory implements Func0<Subject<String, String>> {
 
         @Override
         public Subject<String, String> call() {
             return PublishSubject.<String> create();
         }
-        
+
     }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorObserveOnTest.java b/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
index ef5ab6d332..c5a29e04a2 100644
--- a/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -265,8 +265,8 @@ public void call(Integer t1) {
      * Attempts to confirm that when pauses exist between events, the ScheduledObserver
      * does not lose or reorder any events since the scheduler will not block, but will
      * be re-scheduled when it receives new events after each pause.
-     * 
-     * 
+     *
+     *
      * This is non-deterministic in proving success, but if it ever fails (non-deterministically)
      * it is a sign of potential issues as thread-races and scheduling should not affect output.
      */
@@ -585,22 +585,22 @@ public void testQueueFullEmitsErrorWithVaryingBufferSize() {
         for (int i = 1; i <= 1024; i = i * 2) {
             final int capacity = i;
             System.out.println(">> testQueueFullEmitsErrorWithVaryingBufferSize @ " + i);
-            
+
             PublishSubject<Integer> ps = PublishSubject.create();
-            
+
             TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
-            
+
             TestScheduler test = Schedulers.test();
-            
+
             ps.observeOn(test, capacity).subscribe(ts);
-            
+
             for (int j = 0; j < capacity + 10; j++) {
                 ps.onNext(j);
             }
             ps.onCompleted();
-            
+
             test.advanceTimeBy(1, TimeUnit.SECONDS);
-            
+
             ts.assertNoValues();
             ts.assertError(MissingBackpressureException.class);
             ts.assertNotCompleted();
@@ -619,20 +619,20 @@ public void testAsyncChild() {
     public void testOnErrorCutsAheadOfOnNext() {
         for (int i = 0; i < 50; i++) {
             final PublishSubject<Long> subject = PublishSubject.create();
-    
+
             final AtomicLong counter = new AtomicLong();
             TestSubscriber<Long> ts = new TestSubscriber<Long>(new Observer<Long>() {
-    
+
                 @Override
                 public void onCompleted() {
-    
+
                 }
-    
+
                 @Override
                 public void onError(Throwable e) {
-    
+
                 }
-    
+
                 @Override
                 public void onNext(Long t) {
                     // simulate slow consumer to force backpressure failure
@@ -641,16 +641,16 @@ public void onNext(Long t) {
                     } catch (InterruptedException e) {
                     }
                 }
-    
+
             });
             subject.observeOn(Schedulers.computation()).subscribe(ts);
-    
+
             // this will blow up with backpressure
             while (counter.get() < 102400) {
                 subject.onNext(counter.get());
                 counter.incrementAndGet();
             }
-    
+
             ts.awaitTerminalEvent();
             assertEquals(1, ts.getOnErrorEvents().size());
             assertTrue(ts.getOnErrorEvents().get(0) instanceof MissingBackpressureException);
@@ -741,7 +741,7 @@ public void testRequestOverflow() throws InterruptedException {
                 .subscribe(new Subscriber<Integer>() {
 
                     boolean first = true;
-                    
+
                     @Override
                     public void onStart() {
                         request(2);
@@ -772,7 +772,7 @@ public void onNext(Integer t) {
         assertEquals(100, count.get());
 
     }
-    
+
     @Test
     public void testNoMoreRequestsAfterUnsubscribe() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
@@ -814,18 +814,18 @@ public void onNext(Integer t) {
     @Test
     public void testErrorDelayed() {
         TestScheduler s = Schedulers.test();
-        
+
         Observable<Integer> source = Observable.just(1, 2 ,3)
                 .concatWith(Observable.<Integer>error(new TestException()));
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
 
         source.observeOn(s, true).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         s.advanceTimeBy(1, TimeUnit.SECONDS);
 
         ts.assertNoValues();
@@ -834,38 +834,38 @@ public void testErrorDelayed() {
 
         ts.requestMore(1);
         s.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(3); // requesting 2 doesn't switch to the error() source for some reason in concat.
         s.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         ts.assertValues(1, 2, 3);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testErrorDelayedAsync() {
         Observable<Integer> source = Observable.just(1, 2 ,3)
                 .concatWith(Observable.<Integer>error(new TestException()));
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
 
         source.observeOn(Schedulers.computation(), true).subscribe(ts);
-        
+
         ts.awaitTerminalEvent(2, TimeUnit.SECONDS);
         ts.assertValues(1, 2, 3);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void requestExactCompletesImmediately() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         TestScheduler test = Schedulers.test();
 
         Observable.range(1, 10).observeOn(test).subscribe(ts);
@@ -875,24 +875,24 @@ public void requestExactCompletesImmediately() {
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(10);
 
         test.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         ts.assertValueCount(10);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void fixedReplenishPattern() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
 
         TestScheduler test = Schedulers.test();
-        
+
         final List<Long> requests = new ArrayList<Long>();
-        
+
         Observable.range(1, 100)
         .doOnRequest(new Action1<Long>() {
             @Override
@@ -901,7 +901,7 @@ public void call(Long v) {
             }
         })
         .observeOn(test, 16).subscribe(ts);
-        
+
         test.advanceTimeBy(1, TimeUnit.SECONDS);
         ts.requestMore(20);
         test.advanceTimeBy(1, TimeUnit.SECONDS);
@@ -911,35 +911,35 @@ public void call(Long v) {
         test.advanceTimeBy(1, TimeUnit.SECONDS);
         ts.requestMore(35);
         test.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         ts.assertValueCount(100);
         ts.assertCompleted();
         ts.assertNoErrors();
-        
+
         assertEquals(Arrays.asList(16L, 12L, 12L, 12L, 12L, 12L, 12L, 12L, 12L), requests);
     }
-    
+
     @Test
     public void bufferSizesWork() {
         for (int i = 1; i <= 1024; i = i * 2) {
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             Observable.range(1, 1000 * 1000).observeOn(Schedulers.computation(), i)
             .subscribe(ts);
-            
+
             ts.awaitTerminalEvent();
             ts.assertValueCount(1000 * 1000);
             ts.assertCompleted();
             ts.assertNoErrors();
         }
     }
-    
+
     @Test
     public void synchronousRebatching() {
         final List<Long> requests = new ArrayList<Long>();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-            
+
         Observable.range(1, 50)
         .doOnRequest(new Action1<Long>() {
             @Override
@@ -949,14 +949,14 @@ public void call(Long r) {
         })
        .rebatchRequests(20)
        .subscribe(ts);
-       
+
        ts.assertValueCount(50);
        ts.assertNoErrors();
        ts.assertCompleted();
-       
+
        assertEquals(Arrays.asList(20L, 15L, 15L, 15L), requests);
     }
-    
+
     @Test
     public void rebatchRequestsArgumentCheck() {
         try {
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
index 4008708084..aef7303848 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -238,14 +238,14 @@ public void call(Subscriber<? super Long> s) {
         }
 
     });
-    
+
     private static final Action0 THROWS_NON_FATAL = new Action0() {
 
         @Override
         public void call() {
             throw new RuntimeException();
-        }}; 
-    
+        }};
+
     @Test
     public void testNonFatalExceptionThrownByOnOverflowIsNotReportedByUpstream() {
          final AtomicBoolean errorOccurred = new AtomicBoolean(false);
@@ -267,9 +267,9 @@ public void call(Throwable t) {
     @Test
     public void maxSize() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         Observable.range(1, 10).onBackpressureBuffer(1).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
index c26df3e540..947af54695 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -96,7 +96,7 @@ public void onNext(Long t) {
         ts.assertNoErrors();
         assertEquals(0, ts.getOnNextEvents().get(0).intValue());
     }
-    
+
     @Test
     public void testRequestOverflow() throws InterruptedException {
         final AtomicInteger count = new AtomicInteger();
@@ -107,7 +107,7 @@ public void testRequestOverflow() throws InterruptedException {
             public void onStart() {
                 request(10);
             }
-            
+
             @Override
             public void onCompleted() {
             }
@@ -125,11 +125,11 @@ public void onNext(Long t) {
             }});
         assertEquals(n, count.get());
     }
-    
+
     @Test
     public void testNonFatalExceptionFromOverflowActionIsNotReportedFromUpstreamOperator() {
         final AtomicBoolean errorOccurred = new AtomicBoolean(false);
-        //request 0 
+        //request 0
         TestSubscriber<Long> ts = TestSubscriber.create(0);
         //range method emits regardless of requests so should trigger onBackpressureDrop action
         range(2)
@@ -145,7 +145,7 @@ public void call(Throwable t) {
           .subscribe(ts);
         assertFalse(errorOccurred.get());
     }
-    
+
     @Test
     public void testOnDropMethodIsCalled() {
         final List<Integer> list = new ArrayList<Integer>();
@@ -175,7 +175,7 @@ public void call(Integer t) {
         }).subscribe(ts);
         assertEquals(Arrays.asList(1, 2), list);
     }
-    
+
     @Test
     public void testUpstreamEmitsOnCompletedAfterFailureWithoutCheckingSubscription() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
@@ -206,7 +206,7 @@ public void call(Integer t) {
         ts.assertError(e);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testUpstreamEmitsErrorAfterFailureWithoutCheckingSubscriptionResultsInHooksOnErrorCalled() {
         try {
@@ -250,7 +250,7 @@ public void call(Integer t) {
             RxJavaHooks.setOnError(null);
         }
     }
-    
+
     @Test
     public void testUpstreamEmitsOnNextAfterFailureWithoutCheckingSubscription() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
@@ -281,15 +281,15 @@ public void call(Integer t) {
         ts.assertError(e);
         ts.assertNotCompleted();
     }
-    
-    
-    
+
+
+
     private static final Action1<Long> THROW_NON_FATAL = new Action1<Long>() {
         @Override
         public void call(Long n) {
             throw new RuntimeException();
         }
-    }; 
+    };
 
     static final Observable<Long> infinite = Observable.create(new OnSubscribe<Long>() {
 
@@ -302,7 +302,7 @@ public void call(Subscriber<? super Long> s) {
         }
 
     });
-    
+
     private static final Observable<Long> range(final long n) {
         return Observable.create(new OnSubscribe<Long>() {
 
@@ -316,8 +316,8 @@ public void call(Subscriber<? super Long> s) {
                 }
                 s.onCompleted();
             }
-    
+
         });
     }
-    
+
 }
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java
index 30751f311f..cbcd3d26f8 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java
@@ -30,9 +30,9 @@ public class OperatorOnBackpressureLatestTest {
     @Test
     public void testSimple() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.range(1, 5).onBackpressureLatest().subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5));
@@ -40,10 +40,10 @@ public void testSimple() {
     @Test
     public void testSimpleError() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.range(1, 5).concatWith(Observable.<Integer>error(new TestException()))
         .onBackpressureLatest().subscribe(ts);
-        
+
         ts.assertTerminalEvent();
         Assert.assertEquals(1, ts.getOnErrorEvents().size());
         Assert.assertTrue(ts.getOnErrorEvents().get(0) instanceof TestException);
@@ -57,9 +57,9 @@ public void onStart() {
                 request(2);
             }
         };
-        
+
         Observable.range(1, 5).onBackpressureLatest().subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2));
         Assert.assertEquals(0, ts.getCompletions());
@@ -73,16 +73,16 @@ public void onStart() {
                 request(0);
             }
         };
-        
+
         source.onBackpressureLatest().subscribe(ts);
 
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
 
         source.onNext(1);
         ts.requestMore(2);
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1));
-        
+
         source.onNext(2);
 
         ts.assertReceivedOnNext(Arrays.asList(1, 2));
@@ -95,17 +95,17 @@ public void onStart() {
         ts.requestMore(2);
 
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 6));
-        
+
         source.onNext(7);
 
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 6, 7));
-        
+
         source.onNext(8);
         source.onNext(9);
         source.onCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 6, 7, 9));
         ts.assertNoErrors();
         ts.assertTerminalEvent();
@@ -137,7 +137,7 @@ public void onNext(Integer t) {
         .onBackpressureLatest()
         .observeOn(Schedulers.io())
         .subscribe(ts);
-        
+
         ts.awaitTerminalEvent(2, TimeUnit.SECONDS);
         ts.assertTerminalEvent();
         int n = ts.getOnNextEvents().size();
diff --git a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java
index a7cee6966f..d4ec5d756d 100644
--- a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -231,7 +231,7 @@ public Observable<String> call(Throwable t1) {
         System.out.println(ts.getOnNextEvents());
         ts.assertReceivedOnNext(Arrays.asList("success"));
     }
-    
+
     @Test
     public void testMapResumeAsyncNext() {
         // Trigger multiple failures
@@ -255,7 +255,7 @@ public String call(String s) {
             public Observable<String> call(Throwable t1) {
                 return Observable.just("twoResume", "threeResume").subscribeOn(Schedulers.computation());
             }
-            
+
         });
 
         @SuppressWarnings("unchecked")
@@ -311,7 +311,7 @@ public void run() {
         }
 
     }
-    
+
     @Test
     public void testBackpressure() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -350,18 +350,18 @@ public Integer call(Integer t1) {
     @Test
     public void normalBackpressure() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps.onErrorResumeNext(new Func1<Throwable, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Throwable v) {
                 return Observable.range(3, 2);
             }
         }).subscribe(ts);
-        
+
         ts.requestMore(2);
-        
+
         ps.onNext(1);
         ps.onNext(2);
         ps.onError(new TestException("Forced failure"));
@@ -371,7 +371,7 @@ public Observable<Integer> call(Throwable v) {
         ts.assertNotCompleted();
 
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2, 3, 4);
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java
index d67e1d3814..418324f7f4 100644
--- a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -106,7 +106,7 @@ public String call(String s) {
         verify(observer, times(1)).onNext("twoResume");
         verify(observer, times(1)).onNext("threeResume");
     }
-    
+
     @Test
     public void testResumeNextWithFailedOnSubscribe() {
         Observable<String> testObservable = Observable.create(new OnSubscribe<String>() {
@@ -115,7 +115,7 @@ public void testResumeNextWithFailedOnSubscribe() {
             public void call(Subscriber<? super String> t1) {
                 throw new RuntimeException("force failure");
             }
-            
+
         });
         Observable<String> resume = Observable.just("resume");
         Observable<String> observable = testObservable.onErrorResumeNext(resume);
@@ -128,7 +128,7 @@ public void call(Subscriber<? super String> t1) {
         verify(observer, times(1)).onCompleted();
         verify(observer, times(1)).onNext("resume");
     }
-    
+
     @Test
     public void testResumeNextWithFailedOnSubscribeAsync() {
         Observable<String> testObservable = Observable.create(new OnSubscribe<String>() {
@@ -137,7 +137,7 @@ public void testResumeNextWithFailedOnSubscribeAsync() {
             public void call(Subscriber<? super String> t1) {
                 throw new RuntimeException("force failure");
             }
-            
+
         });
         Observable<String> resume = Observable.just("resume");
         Observable<String> observable = testObservable.subscribeOn(Schedulers.io()).onErrorResumeNext(resume);
@@ -148,7 +148,7 @@ public void call(Subscriber<? super String> t1) {
         observable.subscribe(ts);
 
         ts.awaitTerminalEvent();
-        
+
         verify(observer, Mockito.never()).onError(any(Throwable.class));
         verify(observer, times(1)).onCompleted();
         verify(observer, times(1)).onNext("resume");
@@ -195,7 +195,7 @@ public void run() {
             System.out.println("done starting TestObservable thread");
         }
     }
-    
+
     @Test
     public void testBackpressure() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -227,13 +227,13 @@ public Integer call(Integer t1) {
     @Test
     public void normalBackpressure() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps.onErrorResumeNext(Observable.range(3, 2)).subscribe(ts);
-        
+
         ts.requestMore(2);
-        
+
         ps.onNext(1);
         ps.onNext(2);
         ps.onError(new TestException("Forced failure"));
@@ -243,7 +243,7 @@ public void normalBackpressure() {
         ts.assertNotCompleted();
 
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2, 3, 4);
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java b/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java
index 4124d8d344..1b08ced1ca 100644
--- a/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -108,7 +108,7 @@ public String call(Throwable e) {
         verify(observer, times(0)).onCompleted();
         assertNotNull(capturedException.get());
     }
-    
+
     @Test
     public void testMapResumeAsyncNext() {
         // Trigger multiple failures
@@ -132,7 +132,7 @@ public String call(String s) {
             public String call(Throwable t1) {
                 return "resume";
             }
-            
+
         });
 
         @SuppressWarnings("unchecked")
@@ -148,7 +148,7 @@ public String call(Throwable t1) {
         verify(observer, Mockito.never()).onNext("three");
         verify(observer, times(1)).onNext("resume");
     }
-    
+
     @Test
     public void testBackpressure() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -159,7 +159,7 @@ public void testBackpressure() {
                     public Integer call(Throwable t1) {
                         return 1;
                     }
-                    
+
                 })
                 .observeOn(Schedulers.computation())
                 .map(new Func1<Integer, Integer>() {
@@ -218,22 +218,22 @@ public void run() {
             System.out.println("done starting TestObservable thread");
         }
     }
-    
+
     @Test
     public void normalBackpressure() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps.onErrorReturn(new Func1<Throwable, Integer>() {
             @Override
             public Integer call(Throwable e) {
                 return 3;
             }
         }).subscribe(ts);
-        
+
         ts.requestMore(2);
-        
+
         ps.onNext(1);
         ps.onNext(2);
         ps.onError(new TestException("Forced failure"));
@@ -243,7 +243,7 @@ public Integer call(Throwable e) {
         ts.assertNotCompleted();
 
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2, 3);
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java b/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java
index 6b2d792e9c..7522ae6d86 100644
--- a/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -186,8 +186,8 @@ public String call(String s) {
         verify(observer, Mockito.never()).onError(any(Throwable.class));
         verify(observer, times(1)).onCompleted();
     }
-    
-    
+
+
     @Test
     public void testBackpressure() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -261,17 +261,17 @@ else if ("THROWABLE".equals(s))
             System.out.println("done starting TestObservable thread");
         }
     }
-    
+
     @Test
     public void normalBackpressure() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps.onExceptionResumeNext(Observable.range(3, 2)).subscribe(ts);
-        
+
         ts.requestMore(2);
-        
+
         ps.onNext(1);
         ps.onNext(2);
         ps.onError(new TestException("Forced failure"));
@@ -281,7 +281,7 @@ public void normalBackpressure() {
         ts.assertNotCompleted();
 
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2, 3, 4);
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorPublishFunctionTest.java b/src/test/java/rx/internal/operators/OperatorPublishFunctionTest.java
index cbfa331977..fca83aee19 100644
--- a/src/test/java/rx/internal/operators/OperatorPublishFunctionTest.java
+++ b/src/test/java/rx/internal/operators/OperatorPublishFunctionTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -33,14 +33,14 @@ public class OperatorPublishFunctionTest {
     @Test
     public void concatTakeFirstLastCompletes() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         Observable.range(1, 3).publish(new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Observable<Integer> o) {
                 return Observable.concat(o.take(5), o.takeLast(5));
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(1, 2, 3);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -49,24 +49,24 @@ public Observable<Integer> call(Observable<Integer> o) {
     @Test
     public void concatTakeFirstLastBackpressureCompletes() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0L);
-        
+
         Observable.range(1, 6).publish(new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Observable<Integer> o) {
                 return Observable.concat(o.take(5), o.takeLast(5));
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(5);
-        
+
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(5);
 
         ts.assertValues(1, 2, 3, 4, 5, 6);
@@ -79,26 +79,26 @@ public void canBeCancelled() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
 
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps.publish(new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Observable<Integer> o) {
                 return Observable.concat(o.take(5), o.takeLast(5));
             }
         }).subscribe(ts);
-        
+
         ps.onNext(1);
         ps.onNext(2);
-        
+
         ts.assertValues(1, 2);
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.unsubscribe();
-        
+
         Assert.assertFalse("Source has subscribers?", ps.hasObservers());
     }
-    
+
     @Test
     public void invalidPrefetch() {
         try {
@@ -108,35 +108,35 @@ public void invalidPrefetch() {
             Assert.assertEquals("prefetch > 0 required but it was -99", ex.getMessage());
         }
     }
-    
+
     @Test
     public void takeCompletes() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
 
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps.publish(new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Observable<Integer> o) {
                 return o.take(1);
             }
         }).subscribe(ts);
-        
+
         ps.onNext(1);
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         Assert.assertFalse("Source has subscribers?", ps.hasObservers());
-        
+
     }
-    
+
     @Test
     public void oneStartOnly() {
-        
+
         final AtomicInteger startCount = new AtomicInteger();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onStart() {
@@ -145,36 +145,36 @@ public void onStart() {
         };
 
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps.publish(new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Observable<Integer> o) {
                 return o.take(1);
             }
         }).subscribe(ts);
-        
+
         Assert.assertEquals(1, startCount.get());
     }
-    
+
     @Test
     public void takeCompletesUnsafe() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
 
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps.publish(new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Observable<Integer> o) {
                 return o.take(1);
             }
         }).unsafeSubscribe(ts);
-        
+
         ps.onNext(1);
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         Assert.assertFalse("Source has subscribers?", ps.hasObservers());
     }
 
@@ -183,72 +183,72 @@ public void directCompletesUnsafe() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
 
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps.publish(new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Observable<Integer> o) {
                 return o;
             }
         }).unsafeSubscribe(ts);
-        
+
         ps.onNext(1);
         ps.onCompleted();
-        
+
         ts.assertValues(1);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         Assert.assertFalse("Source has subscribers?", ps.hasObservers());
     }
-    
+
     @Test
     public void overflowMissingBackpressureException() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
 
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ps.publish(new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Observable<Integer> o) {
                 return o;
             }
         }).unsafeSubscribe(ts);
-        
+
         for (int i = 0; i < RxRingBuffer.SIZE * 2; i++) {
             ps.onNext(i);
         }
-        
+
         ts.assertNoValues();
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
-        
+
         Assert.assertEquals("PublishSubject: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
         Assert.assertFalse("Source has subscribers?", ps.hasObservers());
     }
-    
+
     @Test
     public void overflowMissingBackpressureExceptionDelayed() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
 
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         OperatorPublish.create(ps, new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Observable<Integer> o) {
                 return o;
             }
         }, true).unsafeSubscribe(ts);
-        
+
         for (int i = 0; i < RxRingBuffer.SIZE * 2; i++) {
             ps.onNext(i);
         }
-        
+
         ts.requestMore(RxRingBuffer.SIZE);
-        
+
         ts.assertValueCount(RxRingBuffer.SIZE);
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
-        
+
         Assert.assertEquals("PublishSubject: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
         Assert.assertFalse("Source has subscribers?", ps.hasObservers());
     }
diff --git a/src/test/java/rx/internal/operators/OperatorPublishTest.java b/src/test/java/rx/internal/operators/OperatorPublishTest.java
index 0ba6e757bd..ba2f114742 100644
--- a/src/test/java/rx/internal/operators/OperatorPublishTest.java
+++ b/src/test/java/rx/internal/operators/OperatorPublishTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -200,7 +200,7 @@ public void call() {
                     }
                 }).share();
 
-        
+
         final AtomicBoolean child1Unsubscribed = new AtomicBoolean();
         final AtomicBoolean child2Unsubscribed = new AtomicBoolean();
 
@@ -220,7 +220,7 @@ public void call() {
                 super.onNext(t);
             }
         };
-        
+
         source.doOnUnsubscribe(new Action0() {
             @Override
             public void call() {
@@ -228,20 +228,20 @@ public void call() {
             }
         }).take(5)
         .subscribe(ts1);
-        
+
         ts1.awaitTerminalEvent();
         ts2.awaitTerminalEvent();
-        
+
         ts1.assertNoErrors();
         ts2.assertNoErrors();
-        
+
         assertTrue(sourceUnsubscribed.get());
         assertTrue(child1Unsubscribed.get());
         assertTrue(child2Unsubscribed.get());
-        
+
         ts1.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5));
         ts2.assertReceivedOnNext(Arrays.asList(4, 5, 6, 7, 8));
-        
+
         assertEquals(8, sourceEmission.get());
     }
 
@@ -260,7 +260,7 @@ public void testConnectWithNoSubscriber() {
         subscriber.assertNoErrors();
         subscriber.assertTerminalEvent();
     }
-    
+
     @Test
     public void testSubscribeAfterDisconnectThenConnect() {
         ConnectableObservable<Integer> source = Observable.just(1).publish();
@@ -288,7 +288,7 @@ public void testSubscribeAfterDisconnectThenConnect() {
         System.out.println(s);
         System.out.println(s2);
     }
-    
+
     @Test
     public void testNoSubscriberRetentionOnCompleted() {
         OperatorPublish<Integer> source = (OperatorPublish<Integer>)Observable.just(1).publish();
@@ -300,7 +300,7 @@ public void testNoSubscriberRetentionOnCompleted() {
         ts1.assertReceivedOnNext(Arrays.<Integer>asList());
         ts1.assertNoErrors();
         assertEquals(0, ts1.getCompletions());
-        
+
         source.connect();
 
         ts1.assertReceivedOnNext(Arrays.asList(1));
@@ -309,58 +309,58 @@ public void testNoSubscriberRetentionOnCompleted() {
 
         assertNull(source.current.get());
     }
-    
+
     @Test
     public void testNonNullConnection() {
         ConnectableObservable<Object> source = Observable.never().publish();
-        
+
         assertNotNull(source.connect());
         assertNotNull(source.connect());
     }
-    
+
     @Test
     public void testNoDisconnectSomeoneElse() {
         ConnectableObservable<Object> source = Observable.never().publish();
 
         Subscription s1 = source.connect();
         Subscription s2 = source.connect();
-        
+
         s1.unsubscribe();
-        
+
         Subscription s3 = source.connect();
-        
+
         s2.unsubscribe();
-        
+
         assertTrue(s1.isUnsubscribed());
         assertTrue(s2.isUnsubscribed());
         assertFalse(s3.isUnsubscribed());
     }
-    
+
     @Test
     public void testZeroRequested() {
         ConnectableObservable<Integer> source = Observable.just(1).publish();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onStart() {
                 request(0);
             }
         };
-        
+
         source.subscribe(ts);
-        
+
         ts.assertReceivedOnNext(Arrays.<Integer>asList());
         ts.assertNoErrors();
         assertEquals(0, ts.getCompletions());
-        
+
         source.connect();
 
         ts.assertReceivedOnNext(Arrays.<Integer>asList());
         ts.assertNoErrors();
         assertEquals(0, ts.getCompletions());
-        
+
         ts.requestMore(5);
-        
+
         ts.assertReceivedOnNext(Arrays.<Integer>asList(1));
         ts.assertNoErrors();
         ts.assertTerminalEvent();
@@ -374,18 +374,18 @@ public void call(Subscriber<? super Integer> t) {
                 calls.getAndIncrement();
             }
         });
-        
+
         ConnectableObservable<Integer> conn = source.publish();
 
         assertEquals(0, calls.get());
 
         conn.connect();
         conn.connect();
-        
+
         assertEquals(1, calls.get());
-        
+
         conn.connect().unsubscribe();
-        
+
         conn.connect();
         conn.connect();
 
@@ -403,9 +403,9 @@ public void testObserveOn() {
                     tss.add(ts);
                     obs.subscribe(ts);
                 }
-                
+
                 Subscription s = co.connect();
-                
+
                 for (TestSubscriber<Integer> ts : tss) {
                     ts.awaitTerminalEvent(2, TimeUnit.SECONDS);
                     ts.assertTerminalEvent();
diff --git a/src/test/java/rx/internal/operators/OperatorRepeatTest.java b/src/test/java/rx/internal/operators/OperatorRepeatTest.java
index 6e4fff4715..c736b2ef3f 100644
--- a/src/test/java/rx/internal/operators/OperatorRepeatTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRepeatTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -101,9 +101,9 @@ public Integer call(Integer t1) {
     public void testRepeatAndTake() {
         @SuppressWarnings("unchecked")
                 Observer<Object> o = mock(Observer.class);
-        
+
         Observable.just(1).repeat().take(10).subscribe(o);
-        
+
         verify(o, times(10)).onNext(1);
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
@@ -113,9 +113,9 @@ public void testRepeatAndTake() {
     public void testRepeatLimited() {
         @SuppressWarnings("unchecked")
                 Observer<Object> o = mock(Observer.class);
-        
+
         Observable.just(1).repeat(10).subscribe(o);
-        
+
         verify(o, times(10)).onNext(1);
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
@@ -125,22 +125,22 @@ public void testRepeatLimited() {
     public void testRepeatError() {
         @SuppressWarnings("unchecked")
                 Observer<Object> o = mock(Observer.class);
-        
+
         Observable.error(new TestException()).repeat(10).subscribe(o);
-        
+
         verify(o).onError(any(TestException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
-        
+
     }
 
     @Test(timeout = 2000)
     public void testRepeatZero() {
         @SuppressWarnings("unchecked")
                 Observer<Object> o = mock(Observer.class);
-        
+
         Observable.just(1).repeat(0).subscribe(o);
-        
+
         verify(o).onCompleted();
         verify(o, never()).onNext(any());
         verify(o, never()).onError(any(Throwable.class));
@@ -150,14 +150,14 @@ public void testRepeatZero() {
     public void testRepeatOne() {
         @SuppressWarnings("unchecked")
                 Observer<Object> o = mock(Observer.class);
-        
+
         Observable.just(1).repeat(1).subscribe(o);
-        
+
         verify(o).onCompleted();
         verify(o, times(1)).onNext(any());
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     /** Issue #2587. */
     @Test
     public void testRepeatAndDistinctUnbounded() {
@@ -165,11 +165,11 @@ public void testRepeatAndDistinctUnbounded() {
                 .take(3)
                 .repeat(3)
                 .distinct();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         src.subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3));
@@ -195,53 +195,53 @@ public Observable<Integer> call(Integer x) {
         ts.awaitTerminalEvent();
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
-        
+
         assertEquals(Arrays.asList(1, 2, 1, 2, 1, 2, 1, 2, 1, 2), concatBase);
     }
-    
+
     @Test
     public void repeatScheduled() {
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(1).repeat(5, Schedulers.computation()).subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValues(1, 1, 1, 1, 1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings({ "rawtypes", "unchecked" })
     @Test
     public void repeatWhenDefaultScheduler() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(1).repeatWhen((Func1)new Func1<Observable, Observable>() {
             @Override
             public Observable call(Observable o) {
                 return o.take(2);
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(1, 1);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
     }
-    
+
     @SuppressWarnings({ "rawtypes", "unchecked" })
     @Test
     public void repeatWhenTrampolineScheduler() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(1).repeatWhen((Func1)new Func1<Observable, Observable>() {
             @Override
             public Observable call(Observable o) {
                 return o.take(2);
             }
         }, Schedulers.trampoline()).subscribe(ts);
-        
+
         ts.assertValues(1, 1);
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorReplayTest.java b/src/test/java/rx/internal/operators/OperatorReplayTest.java
index d3415d6e6e..e98c542cd8 100644
--- a/src/test/java/rx/internal/operators/OperatorReplayTest.java
+++ b/src/test/java/rx/internal/operators/OperatorReplayTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -487,7 +487,7 @@ public void call(Integer v) {
                 System.out.println("Sideeffect #" + v);
             }
         });
-        
+
         Observable<Integer> result = source.replay(
         new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
@@ -495,7 +495,7 @@ public Observable<Integer> call(Observable<Integer> o) {
                 return o.take(2);
             }
         });
-        
+
         for (int i = 1; i < 3; i++) {
             effectCounter.set(0);
             System.out.printf("- %d -%n", i);
@@ -505,14 +505,14 @@ public Observable<Integer> call(Observable<Integer> o) {
                 public void call(Integer t1) {
                     System.out.println(t1);
                 }
-                
+
             }, new Action1<Throwable>() {
 
                 @Override
                 public void call(Throwable t1) {
                     t1.printStackTrace();
                 }
-            }, 
+            },
             new Action0() {
                 @Override
                 public void call() {
@@ -747,16 +747,16 @@ public void testBoundedReplayBuffer() {
         buf.addLast(new Node(3, 2));
         buf.addLast(new Node(4, 3));
         buf.addLast(new Node(5, 4));
-        
+
         List<Integer> values = new ArrayList<Integer>();
         buf.collect(values);
-        
+
         Assert.assertEquals(Arrays.asList(1, 2, 3, 4, 5), values);
-        
+
         buf.removeSome(2);
         buf.removeFirst();
         buf.removeSome(2);
-        
+
         values.clear();
         buf.collect(values);
         Assert.assertTrue(values.isEmpty());
@@ -764,17 +764,17 @@ public void testBoundedReplayBuffer() {
         buf.addLast(new Node(5, 5));
         buf.addLast(new Node(6, 6));
         buf.collect(values);
-        
+
         Assert.assertEquals(Arrays.asList(5, 6), values);
-        
+
     }
-    
+
     @Test
     public void testTimedAndSizedTruncation() {
         TestScheduler test = Schedulers.test();
         SizeAndTimeBoundReplayBuffer<Integer> buf = new SizeAndTimeBoundReplayBuffer<Integer>(2, 2000, test);
         List<Integer> values = new ArrayList<Integer>();
-        
+
         buf.next(1);
         test.advanceTimeBy(1, TimeUnit.SECONDS);
         buf.next(2);
@@ -793,25 +793,25 @@ public void testTimedAndSizedTruncation() {
         values.clear();
         buf.collect(values);
         Assert.assertEquals(Arrays.asList(3, 4), values);
-        
+
         test.advanceTimeBy(2, TimeUnit.SECONDS);
         buf.next(5);
-        
+
         values.clear();
         buf.collect(values);
         Assert.assertEquals(Arrays.asList(5), values);
-        
+
         test.advanceTimeBy(2, TimeUnit.SECONDS);
         buf.complete();
-        
+
         values.clear();
         buf.collect(values);
         Assert.assertTrue(values.isEmpty());
-        
+
         Assert.assertEquals(1, buf.size);
         Assert.assertTrue(buf.hasCompleted());
     }
-    
+
     @Test
     public void testBackpressure() {
         final AtomicLong requested = new AtomicLong();
@@ -823,26 +823,26 @@ public void call(Long t) {
                     }
                 });
         ConnectableObservable<Integer> co = source.replay();
-        
+
         TestSubscriber<Integer> ts1 = TestSubscriber.create(10);
         TestSubscriber<Integer> ts2 = TestSubscriber.create(90);
-        
+
         co.subscribe(ts1);
         co.subscribe(ts2);
-        
+
         ts2.requestMore(10);
-        
+
         co.connect();
-        
+
         ts1.assertValueCount(10);
         ts1.assertNoTerminalEvent();
-        
+
         ts2.assertValueCount(100);
         ts2.assertNoTerminalEvent();
-        
+
         Assert.assertEquals(100, requested.get());
     }
-    
+
     @Test
     public void testBackpressureBounded() {
         final AtomicLong requested = new AtomicLong();
@@ -854,32 +854,32 @@ public void call(Long t) {
                     }
                 });
         ConnectableObservable<Integer> co = source.replay(50);
-        
+
         TestSubscriber<Integer> ts1 = TestSubscriber.create(10);
         TestSubscriber<Integer> ts2 = TestSubscriber.create(90);
-        
+
         co.subscribe(ts1);
         co.subscribe(ts2);
-        
+
         ts2.requestMore(10);
-        
+
         co.connect();
-        
+
         ts1.assertValueCount(10);
         ts1.assertNoTerminalEvent();
-        
+
         ts2.assertValueCount(100);
         ts2.assertNoTerminalEvent();
-        
+
         Assert.assertEquals(100, requested.get());
     }
-    
+
     @Test
     public void testColdReplayNoBackpressure() {
         Observable<Integer> source = Observable.range(0, 1000).replay().autoConnect();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.subscribe(ts);
 
         ts.assertNoErrors();
@@ -894,10 +894,10 @@ public void testColdReplayNoBackpressure() {
     @Test
     public void testColdReplayBackpressure() {
         Observable<Integer> source = Observable.range(0, 1000).replay().autoConnect();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         ts.requestMore(10);
-        
+
         source.subscribe(ts);
 
         ts.assertNoErrors();
@@ -908,10 +908,10 @@ public void testColdReplayBackpressure() {
         for (int i = 0; i < 10; i++) {
             assertEquals((Integer)i, onNextEvents.get(i));
         }
-        
+
         ts.unsubscribe();
     }
-    
+
     @Test
     public void testCache() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
@@ -972,38 +972,38 @@ public void testUnsubscribeSource() {
         o.subscribe();
         verify(unsubscribe, times(1)).call();
     }
-    
+
     @Test
     public void testTake() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
 
         Observable<Integer> cached = Observable.range(1, 100).replay().autoConnect();
         cached.take(10).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
         ts.assertUnsubscribed();
     }
-    
+
     @Test
     public void testAsync() {
         Observable<Integer> source = Observable.range(1, 10000);
         for (int i = 0; i < 100; i++) {
             TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>();
-            
+
             Observable<Integer> cached = source.replay().autoConnect();
-            
+
             cached.observeOn(Schedulers.computation()).subscribe(ts1);
-            
+
             ts1.awaitTerminalEvent(2, TimeUnit.SECONDS);
             ts1.assertNoErrors();
             ts1.assertTerminalEvent();
             assertEquals(10000, ts1.getOnNextEvents().size());
-            
+
             TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>();
             cached.observeOn(Schedulers.computation()).subscribe(ts2);
-            
+
             ts2.awaitTerminalEvent(2, TimeUnit.SECONDS);
             ts2.assertNoErrors();
             ts2.assertTerminalEvent();
@@ -1016,9 +1016,9 @@ public void testAsyncComeAndGo() {
                 .take(1000)
                 .subscribeOn(Schedulers.io());
         Observable<Long> cached = source.replay().autoConnect();
-        
+
         Observable<Long> output = cached.observeOn(Schedulers.computation());
-        
+
         List<TestSubscriber<Long>> list = new ArrayList<TestSubscriber<Long>>(100);
         for (int i = 0; i < 100; i++) {
             TestSubscriber<Long> ts = new TestSubscriber<Long>();
@@ -1035,17 +1035,17 @@ public void testAsyncComeAndGo() {
             ts.awaitTerminalEvent(3, TimeUnit.SECONDS);
             ts.assertNoErrors();
             ts.assertTerminalEvent();
-            
+
             for (int i = j * 10; i < j * 10 + 10; i++) {
                 expected.set(i - j * 10, (long)i);
             }
-            
+
             ts.assertReceivedOnNext(expected);
-            
+
             j++;
         }
     }
-    
+
     @Test
     public void testNoMissingBackpressureException() {
         final int m;
@@ -1054,7 +1054,7 @@ public void testNoMissingBackpressureException() {
         } else {
             m = 4 * 1000 * 1000;
         }
-        
+
         Observable<Integer> firehose = Observable.create(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
@@ -1064,43 +1064,43 @@ public void call(Subscriber<? super Integer> t) {
                 t.onCompleted();
             }
         });
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         firehose.replay().autoConnect().observeOn(Schedulers.computation()).takeLast(100).subscribe(ts);
-        
+
         ts.awaitTerminalEvent(3, TimeUnit.SECONDS);
         ts.assertNoErrors();
         ts.assertTerminalEvent();
-        
+
         assertEquals(100, ts.getOnNextEvents().size());
     }
-    
+
     @Test
     public void testValuesAndThenError() {
         Observable<Integer> source = Observable.range(1, 10)
                 .concatWith(Observable.<Integer>error(new TestException()))
                 .replay().autoConnect();
-        
-        
+
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         source.subscribe(ts);
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
         Assert.assertEquals(0, ts.getCompletions());
         Assert.assertEquals(1, ts.getOnErrorEvents().size());
-        
+
         TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>();
         source.subscribe(ts2);
-        
+
         ts2.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
         Assert.assertEquals(0, ts2.getCompletions());
         Assert.assertEquals(1, ts2.getOnErrorEvents().size());
     }
-    
+
     @Test
     public void unsafeChildThrows() {
         final AtomicInteger count = new AtomicInteger();
-        
+
         Observable<Integer> source = Observable.range(1, 100)
         .doOnNext(new Action1<Integer>() {
             @Override
@@ -1109,23 +1109,23 @@ public void call(Integer t) {
             }
         })
         .replay().autoConnect();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
                 throw new TestException();
             }
         };
-        
+
         source.unsafeSubscribe(ts);
-        
+
         Assert.assertEquals(100, count.get());
 
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(TestException.class);
     }
-    
+
     @Test
     public void unboundedLeavesEarly() {
         PublishSubject<Integer> source = PublishSubject.create();
@@ -1139,153 +1139,153 @@ public void call(Long t) {
                         requests.add(t);
                     }
                 }).replay().autoConnect();
-        
+
         TestSubscriber<Integer> ts1 = TestSubscriber.create(5);
         TestSubscriber<Integer> ts2 = TestSubscriber.create(10);
-        
+
         out.subscribe(ts1);
         out.subscribe(ts2);
         ts2.unsubscribe();
-        
+
         Assert.assertEquals(Arrays.asList(5L, 5L), requests);
     }
-    
+
     @Test
     public void testSubscribersComeAndGoAtRequestBoundaries() {
         ConnectableObservable<Integer> source = Observable.range(1, 10).replay(1);
         source.connect();
-        
+
         TestSubscriber<Integer> ts1 = TestSubscriber.create(2);
-        
+
         source.subscribe(ts1);
-        
+
         ts1.assertValues(1, 2);
         ts1.assertNoErrors();
         ts1.unsubscribe();
-        
+
         TestSubscriber<Integer> ts2 = TestSubscriber.create(2);
-        
+
         source.subscribe(ts2);
-        
+
         ts2.assertValues(2, 3);
         ts2.assertNoErrors();
         ts2.unsubscribe();
 
         TestSubscriber<Integer> ts21 = TestSubscriber.create(1);
-        
+
         source.subscribe(ts21);
-        
+
         ts21.assertValues(3);
         ts21.assertNoErrors();
         ts21.unsubscribe();
 
         TestSubscriber<Integer> ts22 = TestSubscriber.create(1);
-        
+
         source.subscribe(ts22);
-        
+
         ts22.assertValues(3);
         ts22.assertNoErrors();
         ts22.unsubscribe();
 
-        
+
         TestSubscriber<Integer> ts3 = TestSubscriber.create();
-        
+
         source.subscribe(ts3);
-        
+
         ts3.assertNoErrors();
         System.out.println(ts3.getOnNextEvents());
         ts3.assertValues(3, 4, 5, 6, 7, 8, 9, 10);
         ts3.assertCompleted();
     }
-    
+
     @Test
     public void testSubscribersComeAndGoAtRequestBoundaries2() {
         ConnectableObservable<Integer> source = Observable.range(1, 10).replay(2);
         source.connect();
-        
+
         TestSubscriber<Integer> ts1 = TestSubscriber.create(2);
-        
+
         source.subscribe(ts1);
-        
+
         ts1.assertValues(1, 2);
         ts1.assertNoErrors();
         ts1.unsubscribe();
 
         TestSubscriber<Integer> ts11 = TestSubscriber.create(2);
-        
+
         source.subscribe(ts11);
-        
+
         ts11.assertValues(1, 2);
         ts11.assertNoErrors();
         ts11.unsubscribe();
 
         TestSubscriber<Integer> ts2 = TestSubscriber.create(3);
-        
+
         source.subscribe(ts2);
-        
+
         ts2.assertValues(1, 2, 3);
         ts2.assertNoErrors();
         ts2.unsubscribe();
 
         TestSubscriber<Integer> ts21 = TestSubscriber.create(1);
-        
+
         source.subscribe(ts21);
-        
+
         ts21.assertValues(2);
         ts21.assertNoErrors();
         ts21.unsubscribe();
 
         TestSubscriber<Integer> ts22 = TestSubscriber.create(1);
-        
+
         source.subscribe(ts22);
-        
+
         ts22.assertValues(2);
         ts22.assertNoErrors();
         ts22.unsubscribe();
 
-        
+
         TestSubscriber<Integer> ts3 = TestSubscriber.create();
-        
+
         source.subscribe(ts3);
-        
+
         ts3.assertNoErrors();
         System.out.println(ts3.getOnNextEvents());
         ts3.assertValues(2, 3, 4, 5, 6, 7, 8, 9, 10);
         ts3.assertCompleted();
     }
-    
+
     @Test
     public void dontReplayOldValues() {
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         TestScheduler scheduler = new TestScheduler();
-        
+
         ConnectableObservable<Integer> co = ps.replay(1, TimeUnit.SECONDS, scheduler);
-        
+
         co.subscribe(); // make sure replay runs in unbounded mode
-        
+
         co.connect();
-        
+
         ps.onNext(1);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         ps.onNext(2);
 
         scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
-        
+
         ps.onNext(3);
 
         scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         co.subscribe(ts);
-        
+
         ts.assertValue(3);
     }
-    
+
     @Test
     public void invalidBufferSize() {
         try {
@@ -1294,76 +1294,76 @@ public void invalidBufferSize() {
             assertEquals("bufferSize < 0", ex.getMessage());
         }
     }
-    
+
     @Test
     public void bufferScheduled() {
-        
+
         TestScheduler test = new TestScheduler();
-        
-        
+
+
         ConnectableObservable<Integer> co = Observable.range(1, 5).replay(2, test);
-        
+
         TestSubscriber<Integer> ts1 = TestSubscriber.create();
-        
+
         co.subscribe(ts1);
-        
+
         co.connect();
-        
+
         ts1.assertNoValues();
         ts1.assertNotCompleted();
-        
+
         test.triggerActions();
-        
+
         ts1.assertValues(1, 2, 3, 4, 5);
         ts1.assertNoErrors();
         ts1.assertCompleted();
-        
+
         TestSubscriber<Integer> ts2 = TestSubscriber.create();
-        
+
         co.subscribe(ts2);
-        
+
         ts2.assertNoValues();
         ts2.assertNotCompleted();
-        
+
         test.triggerActions();
-        
+
         ts2.assertValues(4, 5);
         ts2.assertNoErrors();
         ts2.assertCompleted();
     }
-    
+
     @Test
     public void allScheduled() {
-        
+
         TestScheduler test = new TestScheduler();
-        
-        
+
+
         ConnectableObservable<Integer> co = Observable.range(1, 5).replay(test);
-        
+
         TestSubscriber<Integer> ts1 = TestSubscriber.create();
-        
+
         co.subscribe(ts1);
-        
+
         co.connect();
-        
+
         ts1.assertNoValues();
         ts1.assertNotCompleted();
-        
+
         test.triggerActions();
-        
+
         ts1.assertValues(1, 2, 3, 4, 5);
         ts1.assertNoErrors();
         ts1.assertCompleted();
-        
+
         TestSubscriber<Integer> ts2 = TestSubscriber.create();
-        
+
         co.subscribe(ts2);
-        
+
         ts2.assertNoValues();
         ts2.assertNotCompleted();
-        
+
         test.triggerActions();
-        
+
         ts2.assertValues(1, 2, 3, 4, 5);
         ts2.assertNoErrors();
         ts2.assertCompleted();
@@ -1372,44 +1372,44 @@ public void allScheduled() {
     @Test
     public void replayTimedDefaultScheduler() {
         ConnectableObservable<Integer> co = Observable.range(1, 5).replay(2, TimeUnit.SECONDS);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         co.subscribe(ts);
-        
+
         co.connect();
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void bufferTimedSelectorScheduler() {
         Observable<Integer> co = Observable.range(1, 5)
-                .replay(new Func1<Observable<Integer>, Observable<Integer>>() { 
+                .replay(new Func1<Observable<Integer>, Observable<Integer>>() {
                     @Override
                     public Observable<Integer> call(Observable<Integer> t) {
                         return t;
                     }
                 }, 2, 2, TimeUnit.SECONDS, Schedulers.computation());
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         co.subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void bufferTimedSelectorSchedulerBadBuffer() {
         try {
             Observable.range(1, 5)
-                    .replay(new Func1<Observable<Integer>, Observable<Integer>>() { 
+                    .replay(new Func1<Observable<Integer>, Observable<Integer>>() {
                         @Override
                         public Observable<Integer> call(Observable<Integer> t) {
                             return t;
@@ -1419,102 +1419,102 @@ public Observable<Integer> call(Observable<Integer> t) {
             assertEquals("bufferSize < 0", ex.getMessage());
         }
     }
-    
+
     @Test
     public void selectorSizeTimeDefaultScheduler() {
         Observable<Integer> co = Observable.range(1, 5)
-                .replay(new Func1<Observable<Integer>, Observable<Integer>>() { 
+                .replay(new Func1<Observable<Integer>, Observable<Integer>>() {
                     @Override
                     public Observable<Integer> call(Observable<Integer> t) {
                         return t;
                     }
                 }, 2, 2, TimeUnit.SECONDS);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         co.subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void selectorSizeScheduler() {
         Observable<Integer> co = Observable.range(1, 5)
-                .replay(new Func1<Observable<Integer>, Observable<Integer>>() { 
+                .replay(new Func1<Observable<Integer>, Observable<Integer>>() {
                     @Override
                     public Observable<Integer> call(Observable<Integer> t) {
                         return t;
                     }
                 }, 2, Schedulers.computation());
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         co.subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void selectorScheduler() {
         Observable<Integer> co = Observable.range(1, 5)
-                .replay(new Func1<Observable<Integer>, Observable<Integer>>() { 
+                .replay(new Func1<Observable<Integer>, Observable<Integer>>() {
                     @Override
                     public Observable<Integer> call(Observable<Integer> t) {
                         return t;
                     }
                 }, Schedulers.computation());
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         co.subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void timeSizeDefaultScheduler() {
         ConnectableObservable<Integer> co = Observable.range(1, 5)
                 .replay(2, 2, TimeUnit.SECONDS);
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         co.subscribe(ts);
-        
+
         co.connect();
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValues(1, 2, 3, 4, 5);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     void replayNoRetention(Func1<Observable<Integer>, ConnectableObservable<Integer>> replayOp) throws InterruptedException {
         System.gc();
-        
+
         Thread.sleep(500);
-        
+
         MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
         MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
         long initial = memHeap.getUsed();
 
         System.out.printf("Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
-        
+
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         ConnectableObservable<Integer> co = replayOp.call(ps);
-        
+
         Subscription s = co.subscribe(new Action1<Integer>() {
             int[] array = new int[1024 * 1024 * 32];
-            
+
             @Override
             public void call(Integer t) {
                 System.out.println(array.length);
@@ -1522,8 +1522,8 @@ public void call(Integer t) {
         });
 
         co.connect();
-        ps.onNext(1); 
-        
+        ps.onNext(1);
+
         memHeap = memoryMXBean.getHeapMemoryUsage();
         long middle = memHeap.getUsed();
 
@@ -1531,22 +1531,22 @@ public void call(Integer t) {
 
         s.unsubscribe();
         s = null;
-        
+
         System.gc();
-        
+
         Thread.sleep(500);
 
         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("Leak: %.3f -> %.3f -> %.3f", initial / 1024 / 1024.0, middle / 1024 / 1024.0, finish / 1024 / 1024d));
         }
-        
+
     }
-    
+
     @Test
     public void replayNoRetentionUnbounded() throws Exception {
         replayNoRetention(new Func1<Observable<Integer>, ConnectableObservable<Integer>>() {
@@ -1566,7 +1566,7 @@ public ConnectableObservable<Integer> call(Observable<Integer> o) {
             }
         });
     }
-    
+
     @Test
     public void replayNoRetentionTimebound() throws Exception {
         replayNoRetention(new Func1<Observable<Integer>, ConnectableObservable<Integer>>() {
diff --git a/src/test/java/rx/internal/operators/OperatorRetryTest.java b/src/test/java/rx/internal/operators/OperatorRetryTest.java
index 0a63eca489..100891b792 100644
--- a/src/test/java/rx/internal/operators/OperatorRetryTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRetryTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -58,10 +58,10 @@ public void call(Subscriber<? super String> t1) {
                     t1.onNext("hello");
                     t1.onCompleted();
                 }
-                else 
+                else
                     t1.onError(new RuntimeException());
             }
-            
+
         });
         TestSubscriber<String> ts = new TestSubscriber<String>(consumer);
         producer.retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
@@ -84,7 +84,7 @@ public Tuple call(Tuple t, Tuple n) {
                         @Override
                         public Observable<Long> call(Tuple t) {
                             System.out.println("Retry # "+t.count);
-                            return t.count > 20 ? 
+                            return t.count > 20 ?
                                 Observable.<Long>error(t.n) :
                                 Observable.timer(t.count *1L, TimeUnit.MILLISECONDS);
                     }});
@@ -399,7 +399,7 @@ public void call(final Subscriber<? super String> o) {
                 // 0 = not set, 1 = fast path, 2 = backpressure
                 final AtomicInteger path = new AtomicInteger(0);
                 volatile boolean done = false;
-                
+
                 @Override
                 public void request(long n) {
                     if (n == Long.MAX_VALUE && path.compareAndSet(0, 1)) {
@@ -691,7 +691,7 @@ public void testTimeoutWithRetry() {
 
         assertEquals("Start 6 threads, retry 5 then fail on 6", 6, so.efforts.get());
     }
-    
+
     @Test//(timeout = 15000)
     public void testRetryWithBackpressure() throws InterruptedException {
         final int NUM_LOOPS = 1;
@@ -704,7 +704,7 @@ public void testRetryWithBackpressure() throws InterruptedException {
                 TestSubscriber<String> ts = new TestSubscriber<String>(observer);
                 origin.retry().observeOn(Schedulers.computation()).unsafeSubscribe(ts);
                 ts.awaitTerminalEvent(5, TimeUnit.SECONDS);
-                
+
                 InOrder inOrder = inOrder(observer);
                 // should have no errors
                 verify(observer, never()).onError(any(Throwable.class));
@@ -718,7 +718,7 @@ public void testRetryWithBackpressure() throws InterruptedException {
             }
         }
     }
-    
+
     @Test//(timeout = 15000)
     public void testRetryWithBackpressureParallel() throws InterruptedException {
         final int NUM_LOOPS = 1;
@@ -832,7 +832,7 @@ public String call(Integer t1) {
                         return "msg: " + count.incrementAndGet();
                     }
                 });
-        
+
         origin.retry()
         .groupBy(new Func1<String, String>() {
             @Override
@@ -847,7 +847,7 @@ public Observable<String> call(GroupedObservable<String, String> t1) {
             }
         })
         .unsafeSubscribe(new TestSubscriber<String>(observer));
-        
+
         InOrder inOrder = inOrder(observer);
         // should show 3 attempts
         inOrder.verify(observer, times(NUM_MSG)).onNext(any(java.lang.String.class));
@@ -872,11 +872,11 @@ public void testIssue1900SourceNotSupportingBackpressure() {
             public void call(Subscriber<? super String> o) {
                 for(int i=0; i<NUM_MSG; i++) {
                     o.onNext("msg:" + count.incrementAndGet());
-                }   
+                }
                 o.onCompleted();
             }
         });
-        
+
         origin.retry()
         .onBackpressureBuffer() // FIXME the new GroupBy won't request enough for this particular test and retry overflows
         .groupBy(new Func1<String, String>() {
@@ -892,7 +892,7 @@ public Observable<String> call(GroupedObservable<String, String> t1) {
             }
         })
         .unsafeSubscribe(new TestSubscriber<String>(observer));
-        
+
         InOrder inOrder = inOrder(observer);
         // should show 3 attempts
         inOrder.verify(observer, times(NUM_MSG)).onNext(any(java.lang.String.class));
@@ -909,7 +909,7 @@ public Observable<String> call(GroupedObservable<String, String> t1) {
     @Test
     public void retryWhenDefaultScheduler() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(1)
         .concatWith(Observable.<Integer>error(new TestException()))
         .retryWhen((Func1)new Func1<Observable, Observable>() {
@@ -918,18 +918,18 @@ public Observable call(Observable o) {
                 return o.take(2);
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(1, 1);
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
     }
-    
+
     @SuppressWarnings({ "rawtypes", "unchecked" })
     @Test
     public void retryWhenTrampolineScheduler() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(1)
         .concatWith(Observable.<Integer>error(new TestException()))
         .retryWhen((Func1)new Func1<Observable, Observable>() {
@@ -938,7 +938,7 @@ public Observable call(Observable o) {
                 return o.take(2);
             }
         }, Schedulers.trampoline()).subscribe(ts);
-        
+
         ts.assertValues(1, 1);
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java b/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java
index c3d438b200..1fa33dc646 100644
--- a/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java
@@ -66,13 +66,13 @@ public Boolean call(Integer t1, Throwable t2) {
     @Test
     public void testWithNothingToRetry() {
         Observable<Integer> source = Observable.range(0, 3);
-        
+
         @SuppressWarnings("unchecked")
         Observer<Integer> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.retry(retryTwice).subscribe(o);
-        
+
         inOrder.verify(o).onNext(0);
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onNext(2);
@@ -97,11 +97,11 @@ public void call(Subscriber<? super Integer> t1) {
                 t1.onCompleted();
             }
         });
-        
+
         @SuppressWarnings("unchecked")
         Observer<Integer> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.retry(retryTwice).subscribe(o);
 
         inOrder.verify(o).onNext(0);
@@ -112,7 +112,7 @@ public void call(Subscriber<? super Integer> t1) {
         inOrder.verify(o).onNext(3);
         inOrder.verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
-        
+
     }
     @Test
     public void testRetryTwiceAndGiveUp() {
@@ -124,11 +124,11 @@ public void call(Subscriber<? super Integer> t1) {
                 t1.onError(new TestException());
             }
         });
-        
+
         @SuppressWarnings("unchecked")
         Observer<Integer> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.retry(retryTwice).subscribe(o);
 
         inOrder.verify(o).onNext(0);
@@ -139,7 +139,7 @@ public void call(Subscriber<? super Integer> t1) {
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onError(any(TestException.class));
         verify(o, never()).onCompleted();
-        
+
     }
     @Test
     public void testRetryOnSpecificException() {
@@ -159,11 +159,11 @@ public void call(Subscriber<? super Integer> t1) {
                 t1.onCompleted();
             }
         });
-        
+
         @SuppressWarnings("unchecked")
         Observer<Integer> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.retry(retryOnTestException).subscribe(o);
 
         inOrder.verify(o).onNext(0);
@@ -195,11 +195,11 @@ public void call(Subscriber<? super Integer> t1) {
                 t1.onError(te);
             }
         });
-        
+
         @SuppressWarnings("unchecked")
         Observer<Integer> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.retry(retryOnTestException).subscribe(o);
 
         inOrder.verify(o).onNext(0);
@@ -212,7 +212,7 @@ public void call(Subscriber<? super Integer> t1) {
         verify(o, never()).onError(ioe);
         verify(o, never()).onCompleted();
     }
-    
+
     @Test
     public void testUnsubscribeFromRetry() {
         PublishSubject<Integer> subject = PublishSubject.create();
@@ -228,7 +228,7 @@ public void call(Integer n) {
         subject.onNext(2);
         assertEquals(1, count.get());
     }
-    
+
     @Test(timeout = 10000)
     public void testUnsubscribeAfterError() {
 
@@ -282,7 +282,7 @@ public void testTimeoutWithRetry() {
 
         assertEquals("Start 6 threads, retry 5 then fail on 6", 6, so.efforts.get());
     }
-    
+
     @Test
     public void testIssue2826() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -315,7 +315,7 @@ public Integer call(Integer t1) {
 
         assertEquals(1, value);
     }
-    
+
     @Test
     public void testIssue3008RetryWithPredicate() {
         final List<Long> list = new CopyOnWriteArrayList<Long>();
@@ -343,7 +343,7 @@ public void call(Long t) {
             }});
         assertEquals(Arrays.asList(1L,1L,2L,3L), list);
     }
-    
+
     @Test
     public void testIssue3008RetryInfinite() {
         final List<Long> list = new CopyOnWriteArrayList<Long>();
@@ -370,7 +370,7 @@ public void call(Long t) {
     @Test
     public void testBackpressure() {
         final List<Long> requests = new ArrayList<Long>();
-        
+
         Observable<Integer> source = Observable
                 .just(1)
                 .concatWith(Observable.<Integer>error(new TestException()))
@@ -380,7 +380,7 @@ public void call(Long t) {
                         requests.add(t);
                     }
                 });
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create(3);
         source
         .retry(new Func2<Integer, Throwable, Boolean>() {
@@ -389,7 +389,7 @@ public Boolean call(Integer t1, Throwable t2) {
                 return t1 < 3;
             }
         }).subscribe(ts);
-        
+
         assertEquals(Arrays.asList(3L, 2L, 1L), requests);
         ts.assertValues(1, 1, 1);
         ts.assertNotCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorSampleTest.java b/src/test/java/rx/internal/operators/OperatorSampleTest.java
index c05abda5d2..04000973ec 100644
--- a/src/test/java/rx/internal/operators/OperatorSampleTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSampleTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -314,12 +314,12 @@ public void call(Subscriber<? super Integer> subscriber) {
         o.throttleLast(1, TimeUnit.MILLISECONDS).subscribe().unsubscribe();
         verify(s).unsubscribe();
     }
-    
+
     @Test
     public void testSampleOtherUnboundedIn() {
-        
+
         final long[] requested = { -1 };
-        
+
         PublishSubject.create()
         .doOnRequest(new Action1<Long>() {
             @Override
@@ -328,15 +328,15 @@ public void call(Long t) {
             }
         })
         .sample(PublishSubject.create()).subscribe();
-        
+
         Assert.assertEquals(Long.MAX_VALUE, requested[0]);
     }
-    
+
     @Test
     public void testSampleTimedUnboundedIn() {
-        
+
         final long[] requested = { -1 };
-        
+
         PublishSubject.create()
         .doOnRequest(new Action1<Long>() {
             @Override
@@ -345,46 +345,46 @@ public void call(Long t) {
             }
         })
         .sample(1, TimeUnit.SECONDS).subscribe().unsubscribe();
-        
+
         Assert.assertEquals(Long.MAX_VALUE, requested[0]);
     }
-    
+
     @Test
     public void dontUnsubscribeChild1() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         PublishSubject<Integer> sampler = PublishSubject.create();
-        
+
         source.sample(sampler).unsafeSubscribe(ts);
-        
+
         source.onCompleted();
-        
+
         Assert.assertFalse("Source has subscribers?", source.hasObservers());
         Assert.assertFalse("Sampler has subscribers?", sampler.hasObservers());
-        
+
         Assert.assertFalse("TS unsubscribed?", ts.isUnsubscribed());
     }
 
     @Test
     public void dontUnsubscribeChild2() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         PublishSubject<Integer> sampler = PublishSubject.create();
-        
+
         source.sample(sampler).unsafeSubscribe(ts);
-        
+
         sampler.onCompleted();
-        
+
         Assert.assertFalse("Source has subscribers?", source.hasObservers());
         Assert.assertFalse("Sampler has subscribers?", sampler.hasObservers());
-        
+
         Assert.assertFalse("TS unsubscribed?", ts.isUnsubscribed());
     }
-    
+
     @Test
     public void neverSetProducer() {
         Observable<Integer> neverBackpressure = Observable.create(new OnSubscribe<Integer>() {
@@ -398,38 +398,38 @@ public void request(long n) {
                 });
             }
         });
-        
+
         final AtomicInteger count = new AtomicInteger();
-        
+
         neverBackpressure.sample(neverBackpressure).unsafeSubscribe(new Subscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
                 // irrelevant
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 // irrelevant
             }
-            
+
             @Override
             public void onCompleted() {
                 // irrelevant
             }
-            
+
             @Override
             public void setProducer(Producer p) {
                 count.incrementAndGet();
             }
         });
-        
+
         Assert.assertEquals(0, count.get());
     }
-    
+
     @Test
     public void unsubscribeMainAfterCompleted() {
         final AtomicBoolean unsubscribed = new AtomicBoolean();
-        
+
         Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
@@ -441,7 +441,7 @@ public void call() {
                 }));
             }
         });
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onCompleted() {
@@ -452,21 +452,21 @@ public void onCompleted() {
                 }
             }
         };
-        
+
         PublishSubject<Integer> sampler = PublishSubject.create();
-        
+
         source.sample(sampler).unsafeSubscribe(ts);
-        
+
         sampler.onCompleted();
-        
+
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void unsubscribeSamplerAfterCompleted() {
         final AtomicBoolean unsubscribed = new AtomicBoolean();
-        
+
         Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
@@ -478,7 +478,7 @@ public void call() {
                 }));
             }
         });
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onCompleted() {
@@ -489,13 +489,13 @@ public void onCompleted() {
                 }
             }
         };
-        
+
         PublishSubject<Integer> sampled = PublishSubject.create();
-        
+
         sampled.sample(source).unsafeSubscribe(ts);
-        
+
         sampled.onCompleted();
-        
+
         ts.assertNoErrors();
         ts.assertCompleted();
     }
diff --git a/src/test/java/rx/internal/operators/OperatorScanTest.java b/src/test/java/rx/internal/operators/OperatorScanTest.java
index e45f32f92c..c6bf08b718 100644
--- a/src/test/java/rx/internal/operators/OperatorScanTest.java
+++ b/src/test/java/rx/internal/operators/OperatorScanTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -118,7 +118,7 @@ public Integer call(Integer t1, Integer t2) {
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void shouldNotEmitUntilAfterSubscription() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -136,12 +136,12 @@ public Boolean call(Integer t1) {
                 // this will cause request(1) when 0 is emitted
                 return t1 > 0;
             }
-            
+
         }).subscribe(ts);
-        
+
         assertEquals(100, ts.getOnNextEvents().size());
     }
-    
+
     @Test
     public void testBackpressureWithInitialValue() {
         final AtomicInteger count = new AtomicInteger();
@@ -182,7 +182,7 @@ public void onNext(Integer t) {
         // we only expect to receive 10 since we request(10)
         assertEquals(10, count.get());
     }
-    
+
     @Test
     public void testBackpressureWithoutInitialValue() {
         final AtomicInteger count = new AtomicInteger();
@@ -223,7 +223,7 @@ public void onNext(Integer t) {
         // we only expect to receive 10 since we request(10)
         assertEquals(10, count.get());
     }
-    
+
     @Test
     public void testNoBackpressureWithInitialValue() {
         final AtomicInteger count = new AtomicInteger();
@@ -272,7 +272,7 @@ public void testSeedFactory() {
                     public List<Integer> call() {
                         return new ArrayList<Integer>();
                     }
-                    
+
                 }, new Action2<List<Integer>, Integer>() {
 
                     @Override
@@ -350,25 +350,25 @@ public void onNext(Integer integer) {
         verify(producer.get(), never()).request(0);
         verify(producer.get(), times(2)).request(1);
     }
-    
+
     @Test
     public void testInitialValueEmittedNoProducer() {
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         source.scan(0, new Func2<Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2) {
                 return t1 + t2;
             }
         }).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertNotCompleted();
         ts.assertValue(0);
     }
-    
+
     @Test
     public void testInitialValueEmittedWithProducer() {
         Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
@@ -382,25 +382,25 @@ public void request(long n) {
                 });
             }
         });
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         source.scan(0, new Func2<Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2) {
                 return t1 + t2;
             }
         }).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertNotCompleted();
         ts.assertValue(0);
     }
-    
+
     @Test
     public void testInitialValueNull() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 10).scan(null, new Func2<Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2) {
@@ -410,28 +410,28 @@ public Integer call(Integer t1, Integer t2) {
                 return t1 + t2;
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(null, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void testEverythingIsNull() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 6).scan(null, new Func2<Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2) {
                 return null;
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(null, null, null, null, null, null, null);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test(timeout = 1000)
     public void testUnboundedSource() {
         Observable.range(0, Integer.MAX_VALUE)
@@ -451,7 +451,7 @@ public void onNext(Integer t) {
             }
         });
     }
-    
+
     @Test
     public void scanShouldPassUpstreamARequestForMaxValue() {
         final List<Long> requests = new ArrayList<Long>();
@@ -466,7 +466,7 @@ public void call(Long n) {
             public Integer call(Integer t1, Integer t2) {
                 return 0;
             }}).count().subscribe();
-        
+
         assertEquals(Arrays.asList(Long.MAX_VALUE), requests);
     }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java b/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java
index cc2eee6fd2..04ddf01afc 100644
--- a/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSequenceEqualTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/OperatorSerializeTest.java b/src/test/java/rx/internal/operators/OperatorSerializeTest.java
index f126307af5..153df50fa2 100644
--- a/src/test/java/rx/internal/operators/OperatorSerializeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSerializeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -124,14 +124,14 @@ public void testMultiThreadedWithNPEinMiddle() {
         for (int i = 0; i < 3; i++) {
             TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
             Observable<String> w = Observable.create(onSubscribe);
-    
+
             BusyObserver busyobserver = new BusyObserver();
-    
+
             w.serialize().subscribe(busyobserver);
             onSubscribe.waitToFinish();
-    
+
             System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
-            // this should not always be the full number of items since the error should (very often) 
+            // this should not always be the full number of items since the error should (very often)
             // stop it before it completes all 9
             System.out.println("onNext count: " + busyobserver.onNextCount.get());
             if (busyobserver.onNextCount.get() < 9) {
@@ -143,7 +143,7 @@ public void testMultiThreadedWithNPEinMiddle() {
             // non-deterministic because unsubscribe happens after 'waitToFinish' releases
             // so commenting out for now as this is not a critical thing to test here
             // verify(s, times(1)).unsubscribe();
-    
+
             // we can have concurrency ...
             assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
             // ... but the onNext execution should be single threaded
@@ -151,7 +151,7 @@ public void testMultiThreadedWithNPEinMiddle() {
         }
         assertTrue(lessThan9);
     }
-    
+
     /**
      * A thread that will pass data to onNext
      */
@@ -302,7 +302,7 @@ public void run() {
                                             System.out.println("TestMultiThreadedObservable onNext: null");
                                             // force an error
                                             throw npe;
-                                        } else 
+                                        } else
                                             System.out.println("TestMultiThreadedObservable onNext: " + s);
                                         observer.onNext(s);
                                         // capture 'maxThreads'
diff --git a/src/test/java/rx/internal/operators/OperatorSingleTest.java b/src/test/java/rx/internal/operators/OperatorSingleTest.java
index 9bdd630c5d..96459a01d3 100644
--- a/src/test/java/rx/internal/operators/OperatorSingleTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSingleTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -82,7 +82,7 @@ public void testSingleWithEmpty() {
                 isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @Test
     public void testSingleDoesNotRequestMoreThanItNeedsToEmitItem() {
         final AtomicLong request = new AtomicLong();
@@ -124,7 +124,7 @@ public void call(Long n) {
             assertEquals(2, request.get());
         }
     }
-    
+
     @Test
     public void testSingleDoesNotRequestMoreThanItNeedsIf1Then2Requested() {
         final List<Long> requests = new ArrayList<Long>();
@@ -163,7 +163,7 @@ public void onNext(Integer t) {
                 });
         assertEquals(Arrays.asList(2L), requests);
     }
-    
+
     @Test
     public void testSingleDoesNotRequestMoreThanItNeedsIf3Requested() {
         final List<Long> requests = new ArrayList<Long>();
@@ -201,7 +201,7 @@ public void onNext(Integer t) {
                 });
         assertEquals(Arrays.asList(2L), requests);
     }
-    
+
     @Test
     public void testSingleRequestsExactlyWhatItNeedsIf1Requested() {
         final List<Long> requests = new ArrayList<Long>();
@@ -457,17 +457,17 @@ public Integer call(Integer i1, Integer i2) {
         Integer r = reduced.toBlocking().first();
         assertEquals(21, r.intValue());
     }
-    
+
     @Test
     public void defaultBackpressure() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         Observable.<Integer>empty().singleOrDefault(1).subscribe(ts);
-        
+
         ts.assertNoValues();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
         ts.assertCompleted();
         ts.assertNoErrors();
diff --git a/src/test/java/rx/internal/operators/OperatorSkipLastTest.java b/src/test/java/rx/internal/operators/OperatorSkipLastTest.java
index 23ba740026..361e7bcd88 100644
--- a/src/test/java/rx/internal/operators/OperatorSkipLastTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSkipLastTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -132,26 +132,26 @@ public Scheduler call(Scheduler t) {
                 return scheduler;
             }
         });
-        
+
         try {
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             PublishSubject<Integer> ps = PublishSubject.create();
-            
+
             ps.skipLast(1, TimeUnit.SECONDS).subscribe(ts);
-            
+
             ps.onNext(1);
             ps.onNext(2);
             ps.onNext(3);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            
+
             ps.onNext(4);
             ps.onNext(5);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
             ps.onCompleted();
-            
+
             ts.assertValues(1, 2, 3);
             ts.assertNoErrors();
             ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorSkipLastTimedTest.java b/src/test/java/rx/internal/operators/OperatorSkipLastTimedTest.java
index fce0a05f9b..f543f05744 100644
--- a/src/test/java/rx/internal/operators/OperatorSkipLastTimedTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSkipLastTimedTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/OperatorSkipTest.java b/src/test/java/rx/internal/operators/OperatorSkipTest.java
index 2fc14ad5d1..649c562bb2 100644
--- a/src/test/java/rx/internal/operators/OperatorSkipTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSkipTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -148,7 +148,7 @@ public void testSkipError() {
         verify(observer, never()).onCompleted();
 
     }
-    
+
     @Test
     public void testBackpressureMultipleSmallAsyncRequests() throws InterruptedException {
         final AtomicLong requests = new AtomicLong(0);
@@ -169,7 +169,7 @@ public void call(Long n) {
         ts.assertNoErrors();
         assertEquals(6, requests.get());
     }
-    
+
     @Test
     public void testRequestOverflowDoesNotOccur() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(Long.MAX_VALUE-1);
@@ -190,21 +190,21 @@ public Scheduler call(Scheduler t) {
                 return scheduler;
             }
         });
-        
+
         try {
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             PublishSubject<Integer> ps = PublishSubject.create();
-            
+
             ps.skip(1, TimeUnit.SECONDS).subscribe(ts);
-            
+
             ps.onNext(1);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            
+
             ps.onNext(2);
             ps.onCompleted();
-            
+
             ts.assertValue(2);
             ts.assertNoErrors();
             ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorSkipTimedTest.java b/src/test/java/rx/internal/operators/OperatorSkipTimedTest.java
index 1e83be8017..1ccd7ec636 100644
--- a/src/test/java/rx/internal/operators/OperatorSkipTimedTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSkipTimedTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -170,7 +170,7 @@ public void testSkipTimedErrorAfterTime() {
         verify(o, never()).onCompleted();
 
     }
-    
+
     @Test
     public void testSkipTimedUnsubscribePropagatesToUpstream() {
         TestScheduler scheduler = new TestScheduler();
diff --git a/src/test/java/rx/internal/operators/OperatorSkipUntilTest.java b/src/test/java/rx/internal/operators/OperatorSkipUntilTest.java
index 762798ace7..7754be3e6f 100644
--- a/src/test/java/rx/internal/operators/OperatorSkipUntilTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSkipUntilTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/OperatorSkipWhileTest.java b/src/test/java/rx/internal/operators/OperatorSkipWhileTest.java
index d0d8f6960b..f17b3ac07a 100644
--- a/src/test/java/rx/internal/operators/OperatorSkipWhileTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSkipWhileTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -57,14 +57,14 @@ public Boolean call(Integer value) {
             return index++ < 3;
         }
     };
-    
+
     private static final Func1<Integer, Boolean> THROWS_NON_FATAL = new Func1<Integer, Boolean>() {
         @Override
         public Boolean call(Integer values) {
             throw new RuntimeException();
         }
     };
-    
+
     private static final Func1<Integer, Boolean> THROWS_FATAL = new Func1<Integer, Boolean>() {
         @Override
         public Boolean call(Integer values) {
@@ -139,7 +139,7 @@ public void testSkipError() {
         inOrder.verify(w, never()).onCompleted();
         inOrder.verify(w, times(1)).onError(any(RuntimeException.class));
     }
-    
+
     @Test
     public void testPredicateRuntimeError() {
         Observable.just(1).skipWhile(THROWS_NON_FATAL).subscribe(w);
@@ -148,12 +148,12 @@ public void testPredicateRuntimeError() {
         inOrder.verify(w, never()).onCompleted();
         inOrder.verify(w, times(1)).onError(any(RuntimeException.class));
     }
-    
+
     @Test(expected = OutOfMemoryError.class)
     public void testPredicateFatalError() {
         Observable.just(1).skipWhile(THROWS_FATAL).unsafeSubscribe(Subscribers.empty());
     }
-    
+
     @Test
     public void testPredicateRuntimeErrorDoesNotGoUpstreamFirst() {
         final AtomicBoolean errorOccurred = new AtomicBoolean(false);
@@ -166,7 +166,7 @@ public void call(Throwable t) {
         }).skipWhile(THROWS_NON_FATAL).subscribe(ts);
         assertFalse(errorOccurred.get());
     }
-    
+
     @Test
     public void testSkipManySubscribers() {
         Observable<Integer> src = Observable.range(1, 10).skipWhile(LESS_THAN_FIVE);
@@ -175,12 +175,12 @@ public void testSkipManySubscribers() {
             @SuppressWarnings("unchecked")
             Observer<Object> o = mock(Observer.class);
             InOrder inOrder = inOrder(o);
-            
+
             src.subscribe(o);
-            
+
             for (int j = 5; j < 10; j++) {
                 inOrder.verify(o).onNext(j);
-            } 
+            }
             inOrder.verify(o).onCompleted();
             verify(o, never()).onError(any(Throwable.class));
         }
diff --git a/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java b/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
index 7942214b0c..65f1b9870e 100644
--- a/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java b/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
index 332924ba68..12a9b72e5e 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
@@ -142,7 +142,7 @@ public void onStart() {
             }
         };
         Observable.<Integer>empty().switchIfEmpty(Observable.just(1, 2, 3)).subscribe(ts);
-        
+
         assertEquals(Arrays.asList(1), ts.getOnNextEvents());
         ts.assertNoErrors();
         ts.requestMore(1);
@@ -163,7 +163,7 @@ public void onStart() {
         assertTrue(ts.getOnNextEvents().isEmpty());
         ts.assertNoErrors();
     }
-    
+
     @Test
     public void testBackpressureOnFirstObservable() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
@@ -172,7 +172,7 @@ public void testBackpressureOnFirstObservable() {
         ts.assertNoErrors();
         ts.assertNoValues();
     }
-    
+
     @Test(timeout = 10000)
     public void testRequestsNotLost() throws InterruptedException {
         final TestSubscriber<Long> ts = new TestSubscriber<Long>(0);
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchTest.java b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
index 94c5ae236a..9b1d1be8b4 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -533,7 +533,7 @@ public void call(final Subscriber<? super Observable<Integer>> subscriber) {
     @Test
     public void testIssue2654() {
         Observable<String> oneItem = Observable.just("Hello").mergeWith(Observable.<String>never());
-        
+
         Observable<String> src = oneItem.switchMap(new Func1<String, Observable<String>>() {
             @Override
             public Observable<String> call(final String s) {
@@ -549,7 +549,7 @@ public String call(Long i) {
         })
         .share()
         ;
-        
+
         TestSubscriber<String> ts = new TestSubscriber<String>() {
             @Override
             public void onNext(String t) {
@@ -561,17 +561,17 @@ public void onNext(String t) {
             }
         };
         src.subscribe(ts);
-        
+
         ts.awaitTerminalEvent(10, TimeUnit.SECONDS);
-        
+
         System.out.println("> testIssue2654: " + ts.getOnNextEvents().size());
-        
+
         ts.assertTerminalEvent();
         ts.assertNoErrors();
-        
+
         Assert.assertEquals(250, ts.getOnNextEvents().size());
     }
-    
+
     @Test(timeout = 10000)
     public void testInitialRequestsAreAdditive() {
         TestSubscriber<Long> ts = new TestSubscriber<Long>(0);
@@ -590,7 +590,7 @@ public Observable<Long> call(Long t) {
         ts.requestMore(1);
         ts.awaitTerminalEvent();
     }
-    
+
     @Test(timeout = 10000)
     public void testInitialRequestsDontOverflow() {
         TestSubscriber<Long> ts = new TestSubscriber<Long>(0);
@@ -607,8 +607,8 @@ public Observable<Long> call(Long t) {
         ts.awaitTerminalEvent();
         assertTrue(ts.getOnNextEvents().size() > 0);
     }
-    
-    
+
+
     @Test(timeout = 10000)
     public void testSecondaryRequestsDontOverflow() throws InterruptedException {
         TestSubscriber<Long> ts = new TestSubscriber<Long>(0);
@@ -628,7 +628,7 @@ public Observable<Long> call(Long t) {
         ts.awaitTerminalEvent();
         ts.assertValueCount(7);
     }
-    
+
     @Test(timeout = 10000)
     public void testSecondaryRequestsAdditivelyAreMoreThanLongMaxValueInducesMaxValueRequestFromUpstream()
             throws InterruptedException {
@@ -663,20 +663,20 @@ public Observable<Long> call(Long t) {
     @Test
     public void mainError() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         source.switchMapDelayError(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
                 return Observable.range(v, 2);
             }
         }).subscribe(ts);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onError(new TestException());
-        
+
         ts.assertValues(1, 2, 2, 3);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -685,14 +685,14 @@ public Observable<Integer> call(Integer v) {
     @Test
     public void innerError() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(0, 3).switchMapDelayError(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
                 return v == 1 ? Observable.<Integer>error(new TestException()) : Observable.range(v, 2);
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(0, 1, 2, 3);
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -701,22 +701,22 @@ public Observable<Integer> call(Integer v) {
     @Test
     public void innerAllError() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(0, 3).switchMapDelayError(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
                 return Observable.range(v, 2).concatWith(Observable.<Integer>error(new TestException()));
             }
         }).subscribe(ts);
-        
+
         ts.assertValues(0, 1, 1, 2, 2, 3);
         ts.assertError(CompositeException.class);
         ts.assertNotCompleted();
-        
+
         List<Throwable> exceptions = ((CompositeException)ts.getOnErrorEvents().get(0)).getExceptions();
-        
+
         assertEquals(3, exceptions.size());
-        
+
         for (Throwable ex : exceptions) {
             assertTrue(ex.toString(), ex instanceof TestException);
         }
@@ -725,20 +725,20 @@ public Observable<Integer> call(Integer v) {
     @Test
     public void backpressure() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         Observable.range(0, 3).switchMapDelayError(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer v) {
                 return Observable.range(v, 2);
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(2, 3);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -756,27 +756,27 @@ public Observable<Integer> call(Integer v) {
                 return Observable.range(v, 2);
             }
         }).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1);
-        
+
         source.onNext(0);
-        
+
         ts.assertValues(0);
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         source.onNext(1);
 
         ts.assertValues(0);
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValues(0, 1);
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -786,22 +786,22 @@ public Observable<Integer> call(Integer v) {
         ts.requestMore(2);
 
         source.onCompleted();
-        
+
         ts.assertValues(0, 1, 2, 3);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
 
     Object ref;
-    
+
     @Test
     public void producerIsNotRetained() throws Exception {
         ref = new Object();
-        
+
         WeakReference<Object> wr = new WeakReference<Object>(ref);
-        
+
         PublishSubject<Observable<Object>> ps = PublishSubject.create();
-        
+
         Subscriber<Object> observer = new Subscriber<Object>() {
             @Override
             public void onCompleted() {
@@ -815,17 +815,17 @@ public void onError(Throwable e) {
             public void onNext(Object t) {
             }
         };
-        
+
         Observable.switchOnNext(ps).subscribe(observer);
-        
+
         ps.onNext(Observable.just(ref));
-        
+
         ref = null;
-        
+
         System.gc();
-        
+
         Thread.sleep(500);
-        
+
         Assert.assertNotNull(observer); // retain every other referenec in the pipeline
         Assert.assertNotNull(ps);
         Assert.assertNull("Object retained!", wr.get());
@@ -835,11 +835,11 @@ public void onNext(Object t) {
     public void switchAsyncHeavily() {
         for (int i = 1; i < 1024; i *= 2) {
             System.out.println("switchAsyncHeavily >> " + i);
-            
+
             final Queue<Throwable> q = new ConcurrentLinkedQueue<Throwable>();
-            
+
             final long[] lastSeen = { 0L };
-            
+
             final int j = i;
             TestSubscriber<Integer> ts = new TestSubscriber<Integer>(i) {
                 int count;
@@ -853,7 +853,7 @@ public void onNext(Integer t) {
                     }
                 }
             };
-            
+
             Observable.range(1, 10000)
             .observeOn(Schedulers.computation(), i)
             .switchMap(new Func1<Integer, Observable<Integer>>() {
@@ -870,7 +870,7 @@ public void call(Throwable e) {
             })
             .timeout(30, TimeUnit.SECONDS)
             .subscribe(ts);
-            
+
             ts.awaitTerminalEvent(60, TimeUnit.SECONDS);
             if (!q.isEmpty()) {
                 AssertionError ae = new AssertionError("Dropped exceptions");
@@ -883,13 +883,13 @@ public void call(Throwable e) {
             }
         }
     }
-    
+
     @Test
     public void asyncInner() throws Throwable {
         for (int i = 0; i < 100; i++) {
-            
+
             final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-            
+
             Observable.just(Observable.range(1, 1000 * 1000).subscribeOn(Schedulers.computation()))
             .switchMap(UtilityFunctions.<Observable<Integer>>identity())
             .observeOn(Schedulers.computation())
@@ -902,7 +902,7 @@ public void call(Throwable e) {
                     error.set(e);
                 }
             });
-            
+
             Throwable ex = error.get();
             if (ex != null) {
                 throw ex;
diff --git a/src/test/java/rx/internal/operators/OperatorTakeLastOneTest.java b/src/test/java/rx/internal/operators/OperatorTakeLastOneTest.java
index 0ea5bc6be1..752d500895 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeLastOneTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeLastOneTest.java
@@ -88,7 +88,7 @@ public void testLastWithBackpressure() {
         s.requestMore(1);
         assertEquals(1, s.list.size());
     }
-    
+
     @Test
     public void testTakeLastZeroProcessesAllItemsButIgnoresThem() {
         final AtomicInteger upstreamCount = new AtomicInteger();
@@ -103,7 +103,7 @@ public void call(Integer t) {
         assertEquals(num, upstreamCount.get());
         assertEquals(0, count);
     }
-    
+
     private static class MySubscriber<T> extends Subscriber<T> {
 
         private long initialRequest;
diff --git a/src/test/java/rx/internal/operators/OperatorTakeLastTest.java b/src/test/java/rx/internal/operators/OperatorTakeLastTest.java
index beee002ef0..23a4361f0f 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeLastTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeLastTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -263,7 +263,7 @@ public void onNext(Integer integer) {
             }
         });
     }
-    
+
     @Test
     public void testUnsubscribeTakesEffectEarlyOnFastPath() {
         final AtomicInteger count = new AtomicInteger();
@@ -291,7 +291,7 @@ public void onNext(Integer integer) {
         });
         assertEquals(1,count.get());
     }
-    
+
     @Test(timeout=10000)
     public void testRequestOverflow() {
         final List<Integer> list = new ArrayList<Integer>();
@@ -301,15 +301,15 @@ public void testRequestOverflow() {
             public void onStart() {
                 request(2);
             }
-            
+
             @Override
             public void onCompleted() {
-                
+
             }
 
             @Override
             public void onError(Throwable e) {
-                
+
             }
 
             @Override
@@ -319,7 +319,7 @@ public void onNext(Integer t) {
             }});
         assertEquals(50, list.size());
     }
-    
+
     @Test(timeout = 30000) // original could get into an infinite loop
     public void completionRequestRace() {
         Worker w = Schedulers.computation().createWorker();
@@ -331,15 +331,15 @@ public void completionRequestRace() {
                 }
                 PublishSubject<Integer> ps = PublishSubject.create();
                 final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
-                
+
                 ps.takeLast(n).subscribe(ts);
-                
+
                 for (int j = 0; j < n; j++) {
                     ps.onNext(j);
                 }
 
                 final AtomicBoolean go = new AtomicBoolean();
-                
+
                 w.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -347,16 +347,16 @@ public void call() {
                         ts.requestMore(n + 1);
                     }
                 });
-                
+
                 go.set(true);
                 ps.onCompleted();
-                
+
                 ts.awaitTerminalEvent(1, TimeUnit.SECONDS);
-                
+
                 ts.assertValueCount(n);
                 ts.assertNoErrors();
                 ts.assertCompleted();
-                
+
                 List<Integer> list = ts.getOnNextEvents();
                 for (int j = 0; j < n; j++) {
                     Assert.assertEquals(j, list.get(j).intValue());
@@ -370,22 +370,22 @@ public void call() {
     @Test
     public void nullElements() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
-        
+
         Observable.from(new Integer[] { 1, null, 2}).takeLast(4)
         .subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1, null, 2);
         ts.assertCompleted();
         ts.assertNoErrors();
@@ -394,20 +394,20 @@ public void nullElements() {
     @Test
     public void takeLastBuffer() {
         TestSubscriber<List<Integer>> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 5).takeLastBuffer(1).subscribe(ts);
-        
+
         ts.assertValue(Arrays.asList(5));
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void takeLastBufferTimed() {
         TestSubscriber<List<Integer>> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 5).takeLastBuffer(5, TimeUnit.SECONDS).subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValue(Arrays.asList(1, 2, 3, 4, 5));
         ts.assertNoErrors();
@@ -417,21 +417,21 @@ public void takeLastBufferTimed() {
     @Test
     public void takeLastBufferTimedSized() {
         TestSubscriber<List<Integer>> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 5).takeLastBuffer(1, 5, TimeUnit.SECONDS).subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValue(Arrays.asList(5));
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void takeLastBufferTimedIO() {
         TestSubscriber<List<Integer>> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 5).takeLastBuffer(5, TimeUnit.SECONDS, Schedulers.io()).subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValue(Arrays.asList(1, 2, 3, 4, 5));
         ts.assertNoErrors();
@@ -441,9 +441,9 @@ public void takeLastBufferTimedIO() {
     @Test
     public void takeLastBufferTimedSizedIO() {
         TestSubscriber<List<Integer>> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 5).takeLastBuffer(1, 5, TimeUnit.SECONDS, Schedulers.io()).subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValue(Arrays.asList(5));
         ts.assertNoErrors();
diff --git a/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java b/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java
index 9889a720cc..70794d1aa1 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -225,15 +225,15 @@ public void completionRequestRace() {
                 }
                 PublishSubject<Integer> ps = PublishSubject.create();
                 final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
-                
+
                 ps.takeLast(n, 1, TimeUnit.DAYS).subscribe(ts);
-                
+
                 for (int j = 0; j < n; j++) {
                     ps.onNext(j);
                 }
 
                 final AtomicBoolean go = new AtomicBoolean();
-                
+
                 w.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -241,16 +241,16 @@ public void call() {
                         ts.requestMore(n + 1);
                     }
                 });
-                
+
                 go.set(true);
                 ps.onCompleted();
-                
+
                 ts.awaitTerminalEvent(1, TimeUnit.SECONDS);
-                
+
                 ts.assertValueCount(n);
                 ts.assertNoErrors();
                 ts.assertCompleted();
-                
+
                 List<Integer> list = ts.getOnNextEvents();
                 for (int j = 0; j < n; j++) {
                     Assert.assertEquals(j, list.get(j).intValue());
@@ -260,31 +260,31 @@ public void call() {
             w.unsubscribe();
         }
     }
-    
+
     @Test
     public void nullElements() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(0);
-        
+
         Observable.from(new Integer[] { 1, null, 2}).takeLast(4, 1, TimeUnit.DAYS)
         .subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1, null, 2);
         ts.assertCompleted();
         ts.assertNoErrors();
     }
-    
+
     @Test
     public void takeLastDefaultScheduler() {
         final TestScheduler scheduler = new TestScheduler();
@@ -295,24 +295,24 @@ public Scheduler call(Scheduler t) {
                 return scheduler;
             }
         });
-        
+
         try {
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             PublishSubject<Integer> ps = PublishSubject.create();
-            
+
             ps.takeLast(1, TimeUnit.SECONDS).subscribe(ts);
-            
+
             ps.onNext(1);
             ps.onNext(2);
             ps.onNext(3);
-            
+
             scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
-            
+
             ps.onNext(4);
             ps.onNext(5);
             ps.onCompleted();
-            
+
             ts.assertValues(4, 5);
             ts.assertNoErrors();
             ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorTakeTest.java b/src/test/java/rx/internal/operators/OperatorTakeTest.java
index efffdbccc1..c056e8b8f8 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -177,10 +177,10 @@ public void testUnsubscribeAfterTake() {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        
+
         Subscriber<String> subscriber = Subscribers.from(observer);
         subscriber.add(s);
-        
+
         Observable<String> take = w.lift(new OperatorTake<String>(1));
         take.subscribe(subscriber);
 
@@ -289,23 +289,23 @@ public void call(Subscriber<? super Long> op) {
         }
 
     });
-    
+
     @Test(timeout = 2000)
     public void testTakeObserveOn() {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         TestSubscriber<Object> ts = new TestSubscriber<Object>(o);
-        
+
         INFINITE_OBSERVABLE.onBackpressureDrop().observeOn(Schedulers.newThread()).take(1).subscribe(ts);
         ts.awaitTerminalEvent();
         ts.assertNoErrors();
-        
+
         verify(o).onNext(1L);
         verify(o, never()).onNext(2L);
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testProducerRequestThroughTake() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -328,7 +328,7 @@ public void request(long n) {
         }).take(3).subscribe(ts);
         assertEquals(3, requested.get());
     }
-    
+
     @Test
     public void testProducerRequestThroughTakeIsModified() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -351,7 +351,7 @@ public void request(long n) {
         }).take(1).subscribe(ts);
         assertEquals(1, requested.get());
     }
-    
+
     @Test
     public void testInterrupt() throws InterruptedException {
         final AtomicReference<Object> exception = new AtomicReference<Object>();
@@ -375,7 +375,7 @@ public void call(Integer t1) {
         latch.await();
         assertNull(exception.get());
     }
-    
+
     @Test
     public void testDoesntRequestMoreThanNeededFromUpstream() throws InterruptedException {
         final AtomicLong requests = new AtomicLong();
@@ -400,31 +400,31 @@ public void call(Long n) {
         ts.assertNoErrors();
         assertEquals(2,requests.get());
     }
-    
+
     @Test
     public void takeFinalValueThrows() {
         Observable<Integer> source = Observable.just(1).take(1);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
                 throw new TestException();
             }
         };
-        
+
         source.subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @Test
     public void testReentrantTake() {
         final PublishSubject<Integer> source = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source
         .rebatchRequests(2) // take(1) requests 1
         .take(1).doOnNext(new Action1<Integer>() {
@@ -433,9 +433,9 @@ public void call(Integer v) {
                 source.onNext(2);
             }
         }).subscribe(ts);
-        
+
         source.onNext(1);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -451,7 +451,7 @@ public void takeZero() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
 
         Observable.range(1, 1000 * 1000 * 1000).take(0).subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorTakeTimedTest.java b/src/test/java/rx/internal/operators/OperatorTakeTimedTest.java
index 5a718675ff..4b6f439515 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeTimedTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeTimedTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -133,7 +133,7 @@ public void testTakeTimedErrorAfterTime() {
         verify(o, never()).onNext(4);
         verify(o, never()).onError(any(TestException.class));
     }
-    
+
     @Test
     public void takeDefaultScheduler() {
         final TestScheduler scheduler = new TestScheduler();
@@ -144,26 +144,26 @@ public Scheduler call(Scheduler t) {
                 return scheduler;
             }
         });
-        
+
         try {
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             PublishSubject<Integer> ps = PublishSubject.create();
-            
+
             ps.take(1, TimeUnit.SECONDS).subscribe(ts);
-            
+
             ps.onNext(1);
             ps.onNext(2);
             ps.onNext(3);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-            
+
             ps.onNext(4);
             ps.onNext(5);
-            
+
             scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
             ps.onCompleted();
-            
+
             ts.assertValues(1, 2, 3);
             ts.assertNoErrors();
             ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java b/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java
index 06b75c05f4..56df24c666 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeUntilPredicateTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -37,9 +37,9 @@ public class OperatorTakeUntilPredicateTest {
     public void takeEmpty() {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         Observable.empty().takeUntil(UtilityFunctions.alwaysTrue()).subscribe(o);
-        
+
         verify(o, never()).onNext(any());
         verify(o, never()).onError(any(Throwable.class));
         verify(o).onCompleted();
@@ -48,9 +48,9 @@ public void takeEmpty() {
     public void takeAll() {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         Observable.just(1, 2).takeUntil(UtilityFunctions.alwaysFalse()).subscribe(o);
-        
+
         verify(o).onNext(1);
         verify(o).onNext(2);
         verify(o, never()).onError(any(Throwable.class));
@@ -60,9 +60,9 @@ public void takeAll() {
     public void takeFirst() {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         Observable.just(1, 2).takeUntil(UtilityFunctions.alwaysTrue()).subscribe(o);
-        
+
         verify(o).onNext(1);
         verify(o, never()).onNext(2);
         verify(o, never()).onError(any(Throwable.class));
@@ -72,14 +72,14 @@ public void takeFirst() {
     public void takeSome() {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         Observable.just(1, 2, 3).takeUntil(new Func1<Integer, Boolean>() {
             @Override
             public Boolean call(Integer t1) {
                 return t1 == 2;
             }
         }).subscribe(o);
-        
+
         verify(o).onNext(1);
         verify(o).onNext(2);
         verify(o, never()).onNext(3);
@@ -90,14 +90,14 @@ public Boolean call(Integer t1) {
     public void functionThrows() {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         Observable.just(1, 2, 3).takeUntil(new Func1<Integer, Boolean>() {
             @Override
             public Boolean call(Integer t1) {
                 throw new TestException("Forced failure");
             }
         }).subscribe(o);
-        
+
         verify(o).onNext(1);
         verify(o, never()).onNext(2);
         verify(o, never()).onNext(3);
@@ -108,12 +108,12 @@ public Boolean call(Integer t1) {
     public void sourceThrows() {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
-        
+
         Observable.just(1)
         .concatWith(Observable.<Integer>error(new TestException()))
         .concatWith(Observable.just(2))
         .takeUntil(UtilityFunctions.alwaysFalse()).subscribe(o);
-        
+
         verify(o).onNext(1);
         verify(o, never()).onNext(2);
         verify(o).onError(any(TestException.class));
@@ -127,14 +127,14 @@ public void onStart() {
                 request(5);
             }
         };
-        
+
         Observable.range(1, 1000).takeUntil(UtilityFunctions.alwaysFalse()).subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5));
         Assert.assertEquals(0, ts.getCompletions());
     }
-    
+
     @Test
     public void testErrorIncludesLastValueAsCause() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
diff --git a/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java b/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
index 5ffada913e..f51aa9cd26 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -191,28 +191,28 @@ public void call(Subscriber<? super String> observer) {
             observer.add(s);
         }
     }
-    
+
     @Test
     public void testUntilFires() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> until = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.takeUntil(until).unsafeSubscribe(ts);
 
         assertTrue(source.hasObservers());
         assertTrue(until.hasObservers());
 
         source.onNext(1);
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1));
         until.onNext(1);
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1));
         ts.assertNoErrors();
         ts.assertTerminalEvent();
-        
+
         assertFalse("Source still has observers", source.hasObservers());
         assertFalse("Until still has observers", until.hasObservers());
         assertFalse("TestSubscriber is unsubscribed", ts.isUnsubscribed());
@@ -221,9 +221,9 @@ public void testUntilFires() {
     public void testMainCompletes() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> until = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.takeUntil(until).unsafeSubscribe(ts);
 
         assertTrue(source.hasObservers());
@@ -231,11 +231,11 @@ public void testMainCompletes() {
 
         source.onNext(1);
         source.onCompleted();
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1));
         ts.assertNoErrors();
         ts.assertTerminalEvent();
-        
+
         assertFalse("Source still has observers", source.hasObservers());
         assertFalse("Until still has observers", until.hasObservers());
         assertFalse("TestSubscriber is unsubscribed", ts.isUnsubscribed());
@@ -244,44 +244,44 @@ public void testMainCompletes() {
     public void testDownstreamUnsubscribes() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> until = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.takeUntil(until).take(1).unsafeSubscribe(ts);
 
         assertTrue(source.hasObservers());
         assertTrue(until.hasObservers());
 
         source.onNext(1);
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1));
         ts.assertNoErrors();
         ts.assertTerminalEvent();
-        
+
         assertFalse("Source still has observers", source.hasObservers());
         assertFalse("Until still has observers", until.hasObservers());
         assertFalse("TestSubscriber is unsubscribed", ts.isUnsubscribed());
     }
     public void testBackpressure() {
         PublishSubject<Integer> until = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onStart() {
                 requestMore(0);
             }
         };
-        
+
         Observable.range(1, 10).takeUntil(until).unsafeSubscribe(ts);
 
         assertTrue(until.hasObservers());
 
         ts.requestMore(1);
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1));
         ts.assertNoErrors();
         assertEquals("TestSubscriber completed", 0, ts.getCompletions());
-        
+
         assertFalse("Until still has observers", until.hasObservers());
         assertFalse("TestSubscriber is unsubscribed", ts.isUnsubscribed());
     }
diff --git a/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java b/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java
index 8317e41b65..f80b863f9c 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -219,7 +219,7 @@ public void run() {
             System.out.println("done starting TestObservable thread");
         }
     }
-    
+
     @Test
     public void testBackpressure() {
         Observable<Integer> source = Observable.range(1, 1000).takeWhile(new Func1<Integer, Boolean>() {
@@ -234,18 +234,18 @@ public void onStart() {
                 request(5);
             }
         };
-        
+
         source.subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5));
-        
+
         ts.requestMore(5);
 
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
     }
-    
+
     @Test
     public void testNoUnsubscribeDownstream() {
         Observable<Integer> source = Observable.range(1, 1000).takeWhile(new Func1<Integer, Boolean>() {
@@ -255,15 +255,15 @@ public Boolean call(Integer t1) {
             }
         });
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         source.unsafeSubscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1));
-        
+
         Assert.assertFalse("Unsubscribed!", ts.isUnsubscribed());
     }
-    
+
     @Test
     public void testErrorCauseIncludesLastValue() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
@@ -273,10 +273,10 @@ public Boolean call(String t1) {
                 throw new TestException();
             }
         }).subscribe(ts);
-        
+
         ts.assertTerminalEvent();
         ts.assertNoValues();
         assertTrue(ts.getOnErrorEvents().get(0).getCause().getMessage().contains("abc"));
     }
-    
+
 }
diff --git a/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java b/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
index 7bab85cd1d..f608cb22c6 100644
--- a/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
+++ b/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -161,14 +161,14 @@ public void testThrottle() {
         inOrder.verify(observer).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @Test
     public void timed() {
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 2).throttleFirst(1, TimeUnit.SECONDS).subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValue(1);
         ts.assertNoErrors();
diff --git a/src/test/java/rx/internal/operators/OperatorTimeIntervalTest.java b/src/test/java/rx/internal/operators/OperatorTimeIntervalTest.java
index a1e774ed58..bf4fd4735a 100644
--- a/src/test/java/rx/internal/operators/OperatorTimeIntervalTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTimeIntervalTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -74,10 +74,10 @@ public void testTimeInterval() {
         inOrder.verify(observer, times(1)).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @Test
     public void withDefaultScheduler() {
-        
+
         final TestScheduler scheduler = new TestScheduler();
 
         RxJavaHooks.setOnComputationScheduler(new Func1<Scheduler, Scheduler>() {
@@ -86,11 +86,11 @@ public Scheduler call(Scheduler t) {
                 return scheduler;
             }
         });
-        
+
         try {
             InOrder inOrder = inOrder(observer);
             subject.timeInterval().subscribe(observer);
-    
+
             scheduler.advanceTimeBy(1000, TIME_UNIT);
             subject.onNext(1);
             scheduler.advanceTimeBy(2000, TIME_UNIT);
@@ -98,7 +98,7 @@ public Scheduler call(Scheduler t) {
             scheduler.advanceTimeBy(3000, TIME_UNIT);
             subject.onNext(3);
             subject.onCompleted();
-    
+
             inOrder.verify(observer, times(1)).onNext(
                     new TimeInterval<Integer>(1000, 1));
             inOrder.verify(observer, times(1)).onNext(
diff --git a/src/test/java/rx/internal/operators/OperatorTimeoutTests.java b/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
index cc2284efc8..3071d78f6d 100644
--- a/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
+++ b/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -350,58 +350,58 @@ public void call(Subscriber<? super String> subscriber) {
 
         verify(s, times(1)).unsubscribe();
     }
-    
+
     @Test
     public void withDefaultScheduler() {
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(1).timeout(5, TimeUnit.SECONDS).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void withSelector() {
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(1).timeout(new Func1<Integer, Observable<Object>>() {
             @Override
             public Observable<Object> call(Integer t) {
                 return Observable.never();
             }
         }).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void withSelectorAndDefault() {
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(1).timeout(new Func1<Integer, Observable<Object>>() {
             @Override
             public Observable<Object> call(Integer t) {
                 return Observable.never();
             }
         }, Observable.just(2)).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void withSelectorAndDefault2() {
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(1).concatWith(
         Observable.<Integer>never())
         .timeout(new Func1<Integer, Observable<Object>>() {
@@ -410,19 +410,19 @@ public Observable<Object> call(Integer t) {
                 return Observable.just((Object)1);
             }
         }, Observable.just(2)).subscribe(ts);
-        
+
         ts.assertValues(1, 2);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void withDefaultSchedulerAndOther() {
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.just(1).timeout(5, TimeUnit.SECONDS, Observable.just(2)).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java b/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
index b825266a10..456f48a998 100644
--- a/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -104,9 +104,9 @@ public Observable<Integer> call() {
         InOrder inOrder = inOrder(o);
 
         source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
-        
+
         timeout.onNext(1);
-        
+
         inOrder.verify(o).onNext(100);
         inOrder.verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
@@ -425,7 +425,7 @@ public void run() {
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @Test
     public void selectorNull() {
         try {
diff --git a/src/test/java/rx/internal/operators/OperatorTimestampTest.java b/src/test/java/rx/internal/operators/OperatorTimestampTest.java
index 9dd01597fd..11f3fb934f 100644
--- a/src/test/java/rx/internal/operators/OperatorTimestampTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTimestampTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -85,7 +85,7 @@ public void timestampWithScheduler2() {
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, never()).onCompleted();
     }
-    
+
     @Test
     public void withDefaultScheduler() {
         final TestScheduler scheduler = new TestScheduler();
@@ -96,24 +96,24 @@ public Scheduler call(Scheduler t) {
                 return scheduler;
             }
         });
-        
+
         try {
             PublishSubject<Integer> source = PublishSubject.create();
             Observable<Timestamped<Integer>> m = source.timestamp();
             m.subscribe(observer);
-    
+
             source.onNext(1);
             scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
             source.onNext(2);
             scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
             source.onNext(3);
-    
+
             InOrder inOrder = inOrder(observer);
-    
+
             inOrder.verify(observer, times(1)).onNext(new Timestamped<Integer>(0, 1));
             inOrder.verify(observer, times(1)).onNext(new Timestamped<Integer>(100, 2));
             inOrder.verify(observer, times(1)).onNext(new Timestamped<Integer>(200, 3));
-    
+
             verify(observer, never()).onError(any(Throwable.class));
             verify(observer, never()).onCompleted();
         } finally {
diff --git a/src/test/java/rx/internal/operators/OperatorToObservableListTest.java b/src/test/java/rx/internal/operators/OperatorToObservableListTest.java
index 1bf0041d57..0f7c05d4f3 100644
--- a/src/test/java/rx/internal/operators/OperatorToObservableListTest.java
+++ b/src/test/java/rx/internal/operators/OperatorToObservableListTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -50,7 +50,7 @@ public void testList() {
         verify(observer, Mockito.never()).onError(any(Throwable.class));
         verify(observer, times(1)).onCompleted();
     }
-    
+
     @Test
     public void testListViaObservable() {
         Observable<String> w = Observable.from(Arrays.asList("one", "two", "three"));
@@ -116,15 +116,15 @@ public void onStart() {
                 requestMore(0);
             }
         };
-        
+
         w.subscribe(ts);
-        
+
         assertTrue(ts.getOnNextEvents().isEmpty());
         assertTrue(ts.getOnErrorEvents().isEmpty());
         assertEquals(0, ts.getCompletions());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertReceivedOnNext(Collections.singletonList(Arrays.asList(1, 2, 3, 4, 5)));
         assertTrue(ts.getOnErrorEvents().isEmpty());
         assertEquals(1, ts.getCompletions());
diff --git a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
index e679748f85..2fb7bc4d28 100644
--- a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
+++ b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -81,15 +81,15 @@ public void onStart() {
                 requestMore(0);
             }
         };
-        
+
         w.subscribe(ts);
-        
+
         assertTrue(ts.getOnNextEvents().isEmpty());
         assertTrue(ts.getOnErrorEvents().isEmpty());
         assertEquals(0, ts.getCompletions());
-        
+
         ts.requestMore(1);
-        
+
         ts.assertReceivedOnNext(Collections.singletonList(Arrays.asList(1, 2, 3, 4, 5)));
         assertTrue(ts.getOnErrorEvents().isEmpty());
         assertEquals(1, ts.getCompletions());
@@ -147,7 +147,7 @@ static void await(CyclicBarrier cb) {
             ex.printStackTrace();
         }
     }
-    
+
     @Test
     public void testSortedListCapacity() {
         Observable<Integer> w = Observable.just(1, 3, 2, 5, 4);
@@ -159,7 +159,7 @@ public void testSortedListCapacity() {
         testSubscriber.assertNoErrors();
         testSubscriber.assertCompleted();
     }
-    
+
     @Test
     public void testSortedCustomComparer() {
         Observable<Integer> w = Observable.just(1, 3, 2, 5, 4);
@@ -176,7 +176,7 @@ public Integer call(Integer t1, Integer t2) {
         testSubscriber.assertNoErrors();
         testSubscriber.assertCompleted();
     }
-    
+
     @Test
     public void testSortedCustomComparerHinted() {
         Observable<Integer> w = Observable.just(1, 3, 2, 5, 4);
diff --git a/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java b/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
index 9e9b946f28..8e4317af40 100644
--- a/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -169,7 +169,7 @@ public UIEventLoopScheduler() {
             eventLoop = Executors.newSingleThreadExecutor(new RxThreadFactory("Test-EventLoop"));
 
             single = Schedulers.from(eventLoop);
-            
+
             /*
              * DON'T DO THIS IN PRODUCTION CODE
              */
@@ -189,7 +189,7 @@ public void run() {
                 throw new RuntimeException("failed to initialize and get inner thread");
             }
         }
-        
+
         @Override
         public Worker createWorker() {
             return single.createWorker();
diff --git a/src/test/java/rx/internal/operators/OperatorWindowWithObservableTest.java b/src/test/java/rx/internal/operators/OperatorWindowWithObservableTest.java
index 9d6ee60baa..3d7f0c181d 100644
--- a/src/test/java/rx/internal/operators/OperatorWindowWithObservableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorWindowWithObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -287,7 +287,7 @@ public Observable<Object> call() {
         assertEquals(1, ts.getOnNextEvents().size());
         assertEquals(Arrays.asList(1, 2), tsw.getOnNextEvents());
     }
-    
+
     @Test
     public void testWindowViaObservableNoUnsubscribe() {
         Observable<Integer> source = Observable.range(1, 10);
@@ -297,13 +297,13 @@ public Observable<String> call() {
                 return Observable.empty();
             }
         };
-        
+
         TestSubscriber<Observable<Integer>> ts = TestSubscriber.create();
         source.window(boundary).unsafeSubscribe(ts);
-        
+
         assertFalse(ts.isUnsubscribed());
     }
-    
+
     @Test
     public void testBoundaryUnsubscribedOnMainCompletion() {
         PublishSubject<Integer> source = PublishSubject.create();
@@ -314,18 +314,18 @@ public Observable<Integer> call() {
                 return boundary;
             }
         };
-        
+
         TestSubscriber<Observable<Integer>> ts = TestSubscriber.create();
         source.window(boundaryFunc).subscribe(ts);
-        
+
         assertTrue(source.hasObservers());
         assertTrue(boundary.hasObservers());
-        
+
         source.onCompleted();
 
         assertFalse(source.hasObservers());
         assertFalse(boundary.hasObservers());
-        
+
         ts.assertCompleted();
         ts.assertNoErrors();
         ts.assertValueCount(1);
@@ -340,18 +340,18 @@ public Observable<Integer> call() {
                 return boundary;
             }
         };
-        
+
         TestSubscriber<Observable<Integer>> ts = TestSubscriber.create();
         source.window(boundaryFunc).subscribe(ts);
-        
+
         assertTrue(source.hasObservers());
         assertTrue(boundary.hasObservers());
-        
+
         boundary.onCompleted();
 
         assertFalse(source.hasObservers());
         assertFalse(boundary.hasObservers());
-        
+
         ts.assertCompleted();
         ts.assertNoErrors();
         ts.assertValueCount(1);
@@ -366,10 +366,10 @@ public Observable<Integer> call() {
                 return boundary;
             }
         };
-        
+
         TestSubscriber<Observable<Integer>> ts = TestSubscriber.create();
         source.window(boundaryFunc).subscribe(ts);
-        
+
         assertTrue(source.hasObservers());
         assertTrue(boundary.hasObservers());
 
@@ -377,7 +377,7 @@ public Observable<Integer> call() {
 
         assertFalse(source.hasObservers());
         assertFalse(boundary.hasObservers());
-        
+
         ts.assertNotCompleted();
         ts.assertNoErrors();
         ts.assertValueCount(1);
@@ -392,7 +392,7 @@ public Observable<Integer> call() {
                 return boundary;
             }
         };
-        
+
         final TestSubscriber<Integer> ts = TestSubscriber.create(1);
         final TestSubscriber<Observable<Integer>> ts1 = new TestSubscriber<Observable<Integer>>(1) {
             @Override
@@ -403,17 +403,17 @@ public void onNext(Observable<Integer> t) {
         };
         source.window(boundaryFunc)
         .subscribe(ts1);
-        
+
         ts1.assertNoErrors();
         ts1.assertCompleted();
         ts1.assertValueCount(1);
-        
+
         ts.assertNoErrors();
         ts.assertNotCompleted();
         ts.assertValues(1);
-        
+
         ts.requestMore(11);
-        
+
         ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -430,10 +430,10 @@ public Observable<Integer> call() {
                 return boundary;
             }
         };
-        
+
         TestSubscriber<Observable<Integer>> ts = TestSubscriber.create();
         source.window(boundaryFunc).subscribe(ts);
-        
+
         source.onNext(1);
         boundary.onNext(1);
         assertTrue(boundary.hasObservers());
@@ -445,10 +445,10 @@ public Observable<Integer> call() {
         source.onNext(3);
         boundary.onNext(3);
         assertTrue(boundary.hasObservers());
-        
+
         source.onNext(4);
         source.onCompleted();
-        
+
         ts.assertNoErrors();
         ts.assertValueCount(4);
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorWindowWithSizeTest.java b/src/test/java/rx/internal/operators/OperatorWindowWithSizeTest.java
index b44f149588..7f74cd1ee0 100644
--- a/src/test/java/rx/internal/operators/OperatorWindowWithSizeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorWindowWithSizeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -200,16 +200,16 @@ private List<String> list(String... args) {
         }
         return list;
     }
-    
+
     @Test
     public void testBackpressureOuter() {
         Observable<Observable<Integer>> source = Observable.range(1, 10).window(3);
-        
+
         final List<Integer> list = new ArrayList<Integer>();
-        
+
         @SuppressWarnings("unchecked")
         final Observer<Integer> o = mock(Observer.class);
-        
+
         source.subscribe(new Subscriber<Observable<Integer>>() {
             @Override
             public void onStart() {
@@ -241,9 +241,9 @@ public void onCompleted() {
                 o.onCompleted();
             }
         });
-        
+
         assertEquals(Arrays.asList(1, 2, 3), list);
-        
+
         verify(o, never()).onError(any(Throwable.class));
         verify(o, times(1)).onCompleted(); // 1 inner
     }
@@ -269,13 +269,13 @@ public void call(Subscriber<? super Integer> s) {
             }
         }).subscribeOn(Schedulers.newThread()); // use newThread since we are using sleep to block
     }
-    
+
     @Test
     public void testTakeFlatMapCompletes() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         final int indicator = 999999999;
-        
+
         hotStream()
         .window(10)
         .take(2)
@@ -285,18 +285,18 @@ public Observable<Integer> call(Observable<Integer> w) {
                 return w.startWith(indicator);
             }
         }).subscribe(ts);
-        
+
         ts.awaitTerminalEvent(2, TimeUnit.SECONDS);
         ts.assertCompleted();
         Assert.assertFalse(ts.getOnNextEvents().isEmpty());
     }
-    
+
     @Ignore("Requires #3678")
     @Test
     @SuppressWarnings("unchecked")
     public void testBackpressureOuterInexact() {
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>(0);
-        
+
         Observable.range(1, 5).window(2, 1)
         .map(new Func1<Observable<Integer>, Observable<List<Integer>>>() {
             @Override
@@ -305,11 +305,11 @@ public Observable<List<Integer>> call(Observable<Integer> t) {
             }
         }).concatMap(UtilityFunctions.<Observable<List<Integer>>>identity())
         .subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertNoValues();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(2);
 
         ts.assertValues(Arrays.asList(1, 2), Arrays.asList(2, 3));
@@ -319,44 +319,44 @@ public Observable<List<Integer>> call(Observable<Integer> t) {
         ts.requestMore(5);
 
         System.out.println(ts.getOnNextEvents());
-        
+
         ts.assertValues(Arrays.asList(1, 2), Arrays.asList(2, 3),
                 Arrays.asList(3, 4), Arrays.asList(4, 5), Arrays.asList(5));
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void testBackpressureOuterOverlap() {
         Observable<Observable<Integer>> source = Observable.range(1, 10).window(3, 1);
-        
+
         TestSubscriber<Observable<Integer>> ts = TestSubscriber.create(0L);
-        
+
         source.subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValueCount(1);
         ts.assertNoErrors();
         ts.assertNotCompleted();
 
         ts.requestMore(7);
-        
+
         ts.assertValueCount(8);
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(3);
 
         ts.assertValueCount(10);
         ts.assertCompleted();
         ts.assertNoErrors();
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void testCountInvalid() {
         Observable.range(1, 10).window(0, 1);
@@ -369,25 +369,25 @@ public void testSkipInvalid() {
     @Test
     public void testTake1Overlapping() {
         Observable<Observable<Integer>> source = Observable.range(1, 10).window(3, 1).take(1);
-        
+
         TestSubscriber<Observable<Integer>> ts = TestSubscriber.create(0L);
 
         source.subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValueCount(1);
         ts.assertCompleted();
         ts.assertNoErrors();
 
         TestSubscriber<Integer> ts1 = TestSubscriber.create();
-        
+
         ts.getOnNextEvents().get(0).subscribe(ts1);
-        
+
         ts1.assertValues(1, 2, 3);
         ts1.assertCompleted();
         ts1.assertNoErrors();
diff --git a/src/test/java/rx/internal/operators/OperatorWindowWithStartEndObservableTest.java b/src/test/java/rx/internal/operators/OperatorWindowWithStartEndObservableTest.java
index be3c16e660..858465a877 100644
--- a/src/test/java/rx/internal/operators/OperatorWindowWithStartEndObservableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorWindowWithStartEndObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -187,67 +187,67 @@ public void onNext(String args) {
             }
         };
     }
-    
+
     @Test
     public void testNoUnsubscribeAndNoLeak() {
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         PublishSubject<Integer> open = PublishSubject.create();
         final PublishSubject<Integer> close = PublishSubject.create();
-        
+
         TestSubscriber<Observable<Integer>> ts = TestSubscriber.create();
-        
+
         source.window(open, new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t) {
                 return close;
             }
         }).unsafeSubscribe(ts);
-        
+
         open.onNext(1);
         source.onNext(1);
-        
+
         assertTrue(open.hasObservers());
         assertTrue(close.hasObservers());
 
         close.onNext(1);
-        
+
         assertFalse(close.hasObservers());
-        
+
         source.onCompleted();
-        
+
         ts.assertCompleted();
         ts.assertNoErrors();
         ts.assertValueCount(1);
-        
+
         assertFalse(ts.isUnsubscribed());
         assertFalse(open.hasObservers());
         assertFalse(close.hasObservers());
     }
-    
+
     @Test
     public void testUnsubscribeAll() {
         PublishSubject<Integer> source = PublishSubject.create();
-        
+
         PublishSubject<Integer> open = PublishSubject.create();
         final PublishSubject<Integer> close = PublishSubject.create();
-        
+
         TestSubscriber<Observable<Integer>> ts = TestSubscriber.create();
-        
+
         source.window(open, new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t) {
                 return close;
             }
         }).unsafeSubscribe(ts);
-        
+
         open.onNext(1);
-        
+
         assertTrue(open.hasObservers());
         assertTrue(close.hasObservers());
 
         ts.unsubscribe();
-        
+
         assertFalse(open.hasObservers());
         assertFalse(close.hasObservers());
     }
diff --git a/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java b/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java
index a5c41cfc02..71a59ff510 100644
--- a/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -155,12 +155,12 @@ public void onNext(T args) {
     @Test
     public void testExactWindowSize() {
         Observable<Observable<Integer>> source = Observable.range(1, 10).window(1, TimeUnit.MINUTES, 3, scheduler);
-        
+
         final List<Integer> list = new ArrayList<Integer>();
         final List<List<Integer>> lists = new ArrayList<List<Integer>>();
-        
+
         source.subscribe(observeWindow(list, lists));
-        
+
         assertEquals(4, lists.size());
         assertEquals(3, lists.get(0).size());
         assertEquals(Arrays.asList(1, 2, 3), lists.get(0));
@@ -171,13 +171,13 @@ public void testExactWindowSize() {
         assertEquals(1, lists.get(3).size());
         assertEquals(Arrays.asList(10), lists.get(3));
     }
-    
+
     @Test
     public void testTakeFlatMapCompletes() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         final int indicator = 999999999;
-        
+
         OperatorWindowWithSizeTest.hotStream()
         .window(300, TimeUnit.MILLISECONDS)
         .take(10)
@@ -187,7 +187,7 @@ public Observable<Integer> call(Observable<Integer> w) {
                 return w.startWith(indicator);
             }
         }).subscribe(ts);
-        
+
         ts.awaitTerminalEvent(5, TimeUnit.SECONDS);
         ts.assertCompleted();
         Assert.assertFalse(ts.getOnNextEvents().isEmpty());
@@ -195,9 +195,9 @@ public Observable<Integer> call(Observable<Integer> w) {
 
     @Test
     public void timeCountDefaultScheduler() {
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 10).window(5, TimeUnit.SECONDS, 5)
         .flatMap(new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
@@ -205,18 +205,18 @@ public Observable<Integer> call(Observable<Integer> w) {
                 return w;
             }
         }).subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValueCount(10);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void spanSkipDefaultScheduler() {
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 10).window(5, 5, TimeUnit.SECONDS)
         .flatMap(new Func1<Observable<Integer>, Observable<Integer>>() {
             @Override
@@ -224,7 +224,7 @@ public Observable<Integer> call(Observable<Integer> w) {
                 return w;
             }
         }).subscribe(ts);
-        
+
         ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
         ts.assertValueCount(10);
         ts.assertNoErrors();
diff --git a/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java b/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java
index 69506a5d66..126e9e52b6 100644
--- a/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java
+++ b/src/test/java/rx/internal/operators/OperatorWithLatestFromTest.java
@@ -48,101 +48,101 @@ public Integer call(Integer t1, Integer t2) {
     public void testSimple() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> other = PublishSubject.create();
-        
+
         @SuppressWarnings("unchecked")
         Observer<Integer> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         Observable<Integer> result = source.withLatestFrom(other, COMBINER);
-        
+
         result.subscribe(o);
-        
+
         source.onNext(1);
         inOrder.verify(o, never()).onNext(anyInt());
-        
+
         other.onNext(1);
         inOrder.verify(o, never()).onNext(anyInt());
-        
+
         source.onNext(2);
         inOrder.verify(o).onNext((2 << 8) + 1);
-        
+
         other.onNext(2);
         inOrder.verify(o, never()).onNext(anyInt());
-        
+
         other.onCompleted();
         inOrder.verify(o, never()).onCompleted();
-        
+
         source.onNext(3);
         inOrder.verify(o).onNext((3 << 8) + 2);
-        
+
         source.onCompleted();
         inOrder.verify(o).onCompleted();
-        
+
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testEmptySource() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> other = PublishSubject.create();
-        
+
         Observable<Integer> result = source.withLatestFrom(other, COMBINER);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         result.subscribe(ts);
 
         assertTrue(source.hasObservers());
         assertTrue(other.hasObservers());
 
         other.onNext(1);
-        
+
         source.onCompleted();
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         assertEquals(0, ts.getOnNextEvents().size());
-        
+
         assertFalse(source.hasObservers());
         assertFalse(other.hasObservers());
     }
-    
+
     @Test
     public void testEmptyOther() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> other = PublishSubject.create();
-        
+
         Observable<Integer> result = source.withLatestFrom(other, COMBINER);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         result.subscribe(ts);
 
         assertTrue(source.hasObservers());
         assertTrue(other.hasObservers());
 
         source.onNext(1);
-        
+
         source.onCompleted();
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         assertEquals(0, ts.getOnNextEvents().size());
-        
+
         assertFalse(source.hasObservers());
         assertFalse(other.hasObservers());
     }
-    
-    
+
+
     @Test
     public void testUnsubscription() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> other = PublishSubject.create();
-        
+
         Observable<Integer> result = source.withLatestFrom(other, COMBINER);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         result.subscribe(ts);
 
         assertTrue(source.hasObservers());
@@ -150,13 +150,13 @@ public void testUnsubscription() {
 
         other.onNext(1);
         source.onNext(1);
-        
+
         ts.unsubscribe();
-        
+
         ts.assertReceivedOnNext(Arrays.asList((1 << 8) + 1));
         ts.assertNoErrors();
         assertEquals(0, ts.getCompletions());
-        
+
         assertFalse(source.hasObservers());
         assertFalse(other.hasObservers());
     }
@@ -165,11 +165,11 @@ public void testUnsubscription() {
     public void testSourceThrows() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> other = PublishSubject.create();
-        
+
         Observable<Integer> result = source.withLatestFrom(other, COMBINER);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         result.subscribe(ts);
 
         assertTrue(source.hasObservers());
@@ -177,14 +177,14 @@ public void testSourceThrows() {
 
         other.onNext(1);
         source.onNext(1);
-        
+
         source.onError(new TestException());
-        
+
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList((1 << 8) + 1));
         assertEquals(1, ts.getOnErrorEvents().size());
         assertTrue(ts.getOnErrorEvents().get(0) instanceof TestException);
-        
+
         assertFalse(source.hasObservers());
         assertFalse(other.hasObservers());
     }
@@ -192,11 +192,11 @@ public void testSourceThrows() {
     public void testOtherThrows() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> other = PublishSubject.create();
-        
+
         Observable<Integer> result = source.withLatestFrom(other, COMBINER);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         result.subscribe(ts);
 
         assertTrue(source.hasObservers());
@@ -204,27 +204,27 @@ public void testOtherThrows() {
 
         other.onNext(1);
         source.onNext(1);
-        
+
         other.onError(new TestException());
-        
+
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList((1 << 8) + 1));
         assertEquals(1, ts.getOnErrorEvents().size());
         assertTrue(ts.getOnErrorEvents().get(0) instanceof TestException);
-        
+
         assertFalse(source.hasObservers());
         assertFalse(other.hasObservers());
     }
-    
+
     @Test
     public void testFunctionThrows() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> other = PublishSubject.create();
-        
+
         Observable<Integer> result = source.withLatestFrom(other, COMBINER_ERROR);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         result.subscribe(ts);
 
         assertTrue(source.hasObservers());
@@ -232,65 +232,65 @@ public void testFunctionThrows() {
 
         other.onNext(1);
         source.onNext(1);
-        
+
         ts.assertTerminalEvent();
         assertEquals(0, ts.getOnNextEvents().size());
         assertEquals(1, ts.getOnErrorEvents().size());
         assertTrue(ts.getOnErrorEvents().get(0) instanceof TestException);
-        
+
         assertFalse(source.hasObservers());
         assertFalse(other.hasObservers());
     }
-    
+
     @Test
     public void testNoDownstreamUnsubscribe() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> other = PublishSubject.create();
-        
+
         Observable<Integer> result = source.withLatestFrom(other, COMBINER);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
+
         result.unsafeSubscribe(ts);
-        
+
         source.onCompleted();
-        
+
         assertFalse(ts.isUnsubscribed());
     }
     @Test
     public void testBackpressure() {
         Observable<Integer> source = Observable.range(1, 10);
         PublishSubject<Integer> other = PublishSubject.create();
-        
+
         Observable<Integer> result = source.withLatestFrom(other, COMBINER);
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onStart() {
                 request(0);
             }
         };
-        
+
         result.subscribe(ts);
-        
+
         ts.requestMore(1);
-        
+
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
-        
+
         other.onNext(1);
-        
+
         ts.requestMore(1);
-        
+
         ts.assertReceivedOnNext(Arrays.asList((2 << 8) + 1));
-        
+
         ts.requestMore(5);
         ts.assertReceivedOnNext(Arrays.asList(
-                (2 << 8) + 1, (3 << 8) + 1, (4 << 8) + 1, (5 << 8) + 1, 
-                (6 << 8) + 1, (7 << 8) + 1 
+                (2 << 8) + 1, (3 << 8) + 1, (4 << 8) + 1, (5 << 8) + 1,
+                (6 << 8) + 1, (7 << 8) + 1
         ));
-        
+
         ts.unsubscribe();
-        
+
         assertFalse("Other has observers!", other.hasObservers());
 
         ts.assertNoErrors();
@@ -309,12 +309,12 @@ public void manySources() {
         PublishSubject<String> ps2 = PublishSubject.create();
         PublishSubject<String> ps3 = PublishSubject.create();
         PublishSubject<String> main = PublishSubject.create();
-        
+
         TestSubscriber<String> ts = new TestSubscriber<String>();
-        
+
         main.withLatestFrom(new Observable[] { ps1, ps2, ps3 }, toArray)
         .subscribe(ts);
-        
+
         main.onNext("1");
         ts.assertNoValues();
         ps1.onNext("a");
@@ -323,45 +323,45 @@ public void manySources() {
         ts.assertNoValues();
         ps3.onNext("=");
         ts.assertNoValues();
-        
+
         main.onNext("2");
         ts.assertValues("[2, a, A, =]");
-        
+
         ps2.onNext("B");
-        
+
         ts.assertValues("[2, a, A, =]");
-        
+
         ps3.onCompleted();
         ts.assertValues("[2, a, A, =]");
-        
+
         ps1.onNext("b");
-        
+
         main.onNext("3");
-        
+
         ts.assertValues("[2, a, A, =]", "[3, b, B, =]");
-        
+
         main.onCompleted();
         ts.assertValues("[2, a, A, =]", "[3, b, B, =]");
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         Assert.assertFalse("ps1 has subscribers?", ps1.hasObservers());
         Assert.assertFalse("ps2 has subscribers?", ps2.hasObservers());
         Assert.assertFalse("ps3 has subscribers?", ps3.hasObservers());
     }
-    
+
     @Test
     public void manySourcesIterable() {
         PublishSubject<String> ps1 = PublishSubject.create();
         PublishSubject<String> ps2 = PublishSubject.create();
         PublishSubject<String> ps3 = PublishSubject.create();
         PublishSubject<String> main = PublishSubject.create();
-        
+
         TestSubscriber<String> ts = new TestSubscriber<String>();
-        
+
         main.withLatestFrom(Arrays.<Observable<?>>asList(ps1, ps2, ps3), toArray)
         .subscribe(ts);
-        
+
         main.onNext("1");
         ts.assertNoValues();
         ps1.onNext("a");
@@ -370,33 +370,33 @@ public void manySourcesIterable() {
         ts.assertNoValues();
         ps3.onNext("=");
         ts.assertNoValues();
-        
+
         main.onNext("2");
         ts.assertValues("[2, a, A, =]");
-        
+
         ps2.onNext("B");
-        
+
         ts.assertValues("[2, a, A, =]");
-        
+
         ps3.onCompleted();
         ts.assertValues("[2, a, A, =]");
-        
+
         ps1.onNext("b");
-        
+
         main.onNext("3");
-        
+
         ts.assertValues("[2, a, A, =]", "[3, b, B, =]");
-        
+
         main.onCompleted();
         ts.assertValues("[2, a, A, =]", "[3, b, B, =]");
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         Assert.assertFalse("ps1 has subscribers?", ps1.hasObservers());
         Assert.assertFalse("ps2 has subscribers?", ps2.hasObservers());
         Assert.assertFalse("ps3 has subscribers?", ps3.hasObservers());
     }
-    
+
     @Test
     public void manySourcesIterableSweep() {
         for (String val : new String[] { "1", null }) {
@@ -405,93 +405,93 @@ public void manySourcesIterableSweep() {
                 List<Observable<?>> sources = new ArrayList<Observable<?>>();
                 List<String> expected = new ArrayList<String>();
                 expected.add(val);
-                
+
                 for (int j = 0; j < i; j++) {
                     sources.add(Observable.just(val));
                     expected.add(String.valueOf(val));
                 }
-                
+
                 TestSubscriber<String> ts = new TestSubscriber<String>();
-                
+
                 PublishSubject<String> main = PublishSubject.create();
-                
+
                 main.withLatestFrom(sources, toArray).subscribe(ts);
-                
+
                 ts.assertNoValues();
-                
+
                 main.onNext(val);
                 main.onCompleted();
-                
+
                 ts.assertValue(expected.toString());
                 ts.assertNoErrors();
                 ts.assertCompleted();
             }
         }
     }
-    
+
     @Test
     public void backpressureNoSignal() {
         PublishSubject<String> ps1 = PublishSubject.create();
         PublishSubject<String> ps2 = PublishSubject.create();
-        
+
         TestSubscriber<String> ts = new TestSubscriber<String>(0);
-        
+
         Observable.range(1, 10).withLatestFrom(new Observable<?>[] { ps1, ps2 }, toArray)
         .subscribe(ts);
-        
+
         ts.assertNoValues();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         Assert.assertFalse("ps1 has subscribers?", ps1.hasObservers());
         Assert.assertFalse("ps2 has subscribers?", ps2.hasObservers());
     }
-    
+
     @Test
     public void backpressureWithSignal() {
         PublishSubject<String> ps1 = PublishSubject.create();
         PublishSubject<String> ps2 = PublishSubject.create();
-        
+
         TestSubscriber<String> ts = new TestSubscriber<String>(0);
-        
+
         Observable.range(1, 3).withLatestFrom(new Observable<?>[] { ps1, ps2 }, toArray)
         .subscribe(ts);
-        
+
         ts.assertNoValues();
-        
+
         ps1.onNext("1");
         ps2.onNext("1");
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue("[1, 1, 1]");
-        
+
         ts.requestMore(1);
 
         ts.assertValues("[1, 1, 1]", "[2, 1, 1]");
 
         ts.requestMore(1);
-        
+
         ts.assertValues("[1, 1, 1]", "[2, 1, 1]", "[3, 1, 1]");
         ts.assertNoErrors();
         ts.assertCompleted();
-        
+
         Assert.assertFalse("ps1 has subscribers?", ps1.hasObservers());
         Assert.assertFalse("ps2 has subscribers?", ps2.hasObservers());
     }
-    
+
     @Test
     public void withEmpty() {
         TestSubscriber<String> ts = new TestSubscriber<String>(0);
-        
+
         Observable.range(1, 3).withLatestFrom(
                 new Observable<?>[] { Observable.just(1), Observable.empty() }, toArray)
         .subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -500,11 +500,11 @@ public void withEmpty() {
     @Test
     public void withError() {
         TestSubscriber<String> ts = new TestSubscriber<String>(0);
-        
+
         Observable.range(1, 3).withLatestFrom(
                 new Observable<?>[] { Observable.just(1), Observable.error(new TestException()) }, toArray)
         .subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -513,11 +513,11 @@ public void withError() {
     @Test
     public void withMainError() {
         TestSubscriber<String> ts = new TestSubscriber<String>(0);
-        
+
         Observable.error(new TestException()).withLatestFrom(
                 new Observable<?>[] { Observable.just(1), Observable.just(1) }, toArray)
         .subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
@@ -526,9 +526,9 @@ public void withMainError() {
     @Test
     public void with2Others() {
         Observable<Integer> just = Observable.just(1);
-        
+
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
-        
+
         just.withLatestFrom(just, just, new Func3<Integer, Integer, Integer, List<Integer>>() {
             @Override
             public List<Integer> call(Integer a, Integer b, Integer c) {
@@ -536,18 +536,18 @@ public List<Integer> call(Integer a, Integer b, Integer c) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue(Arrays.asList(1, 1, 1));
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void with3Others() {
         Observable<Integer> just = Observable.just(1);
-        
+
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
-        
+
         just.withLatestFrom(just, just, just, new Func4<Integer, Integer, Integer, Integer, List<Integer>>() {
             @Override
             public List<Integer> call(Integer a, Integer b, Integer c, Integer d) {
@@ -555,18 +555,18 @@ public List<Integer> call(Integer a, Integer b, Integer c, Integer d) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue(Arrays.asList(1, 1, 1, 1));
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void with4Others() {
         Observable<Integer> just = Observable.just(1);
-        
+
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
-        
+
         just.withLatestFrom(just, just, just, just, new Func5<Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
             @Override
             public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e) {
@@ -574,18 +574,18 @@ public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e)
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue(Arrays.asList(1, 1, 1, 1, 1));
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void with5Others() {
         Observable<Integer> just = Observable.just(1);
-        
+
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
-        
+
         just.withLatestFrom(just, just, just, just, just, new Func6<Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
             @Override
             public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f) {
@@ -593,18 +593,18 @@ public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e,
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue(Arrays.asList(1, 1, 1, 1, 1, 1));
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void with6Others() {
         Observable<Integer> just = Observable.just(1);
-        
+
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
-        
+
         just.withLatestFrom(just, just, just, just, just, just, new Func7<Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
             @Override
             public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f, Integer g) {
@@ -612,18 +612,18 @@ public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e,
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue(Arrays.asList(1, 1, 1, 1, 1, 1, 1));
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void with7Others() {
         Observable<Integer> just = Observable.just(1);
-        
+
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
-        
+
         just.withLatestFrom(just, just, just, just, just, just, just, new Func8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
             @Override
             public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f, Integer g, Integer i) {
@@ -631,7 +631,7 @@ public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e,
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue(Arrays.asList(1, 1, 1, 1, 1, 1, 1, 1));
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -640,9 +640,9 @@ public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e,
     @Test
     public void with8Others() {
         Observable<Integer> just = Observable.just(1);
-        
+
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
-        
+
         just.withLatestFrom(just, just, just, just, just, just, just, just, new Func9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
             @Override
             public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f, Integer g, Integer i, Integer j) {
@@ -650,7 +650,7 @@ public List<Integer> call(Integer a, Integer b, Integer c, Integer d, Integer e,
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue(Arrays.asList(1, 1, 1, 1, 1, 1, 1, 1, 1));
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorZipCompletionTest.java b/src/test/java/rx/internal/operators/OperatorZipCompletionTest.java
index ef5ddb6847..33bc5c9ab1 100644
--- a/src/test/java/rx/internal/operators/OperatorZipCompletionTest.java
+++ b/src/test/java/rx/internal/operators/OperatorZipCompletionTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -31,7 +31,7 @@
 /**
  * Systematically tests that when zipping an infinite and a finite Observable,
  * the resulting Observable is finite.
- * 
+ *
  */
 public class OperatorZipCompletionTest {
     Func2<String, String, String> concat2Strings;
diff --git a/src/test/java/rx/internal/operators/OperatorZipIterableTest.java b/src/test/java/rx/internal/operators/OperatorZipIterableTest.java
index 2aa2ed9a9d..d82465428d 100644
--- a/src/test/java/rx/internal/operators/OperatorZipIterableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorZipIterableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -353,7 +353,7 @@ public void remove() {
         verify(o, never()).onCompleted();
 
     }
-    
+
     Action1<String> printer = new Action1<String>() {
         @Override
         public void call(String t1) {
@@ -374,11 +374,11 @@ public String call(Integer t1) {
     @Test public void testTake2() {
         Observable<Integer> o = Observable.just(1, 2, 3, 4, 5);
         Iterable<String> it = Arrays.asList("a", "b", "c", "d", "e");
-        
+
         SquareStr squareStr = new SquareStr();
-        
+
         o.map(squareStr).zipWith(it, concat2Strings).take(2).subscribe(printer);
-        
+
         assertEquals(2, squareStr.counter.get());
     }
 
diff --git a/src/test/java/rx/internal/operators/OperatorZipTest.java b/src/test/java/rx/internal/operators/OperatorZipTest.java
index 5bc901bcc6..950d506201 100644
--- a/src/test/java/rx/internal/operators/OperatorZipTest.java
+++ b/src/test/java/rx/internal/operators/OperatorZipTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -1291,7 +1291,7 @@ public Integer call(Integer t1, Integer t2) {
                 return t1 + 10 * t2;
             }
         });
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
@@ -1299,9 +1299,9 @@ public void onNext(Integer t) {
                 requestMore(5);
             }
         };
-        
+
         source.subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList(11, 22));
@@ -1310,7 +1310,7 @@ public void onNext(Integer t) {
     public void testZipRace() {
         long startTime = System.currentTimeMillis();
         Observable<Integer> src = Observable.just(1).subscribeOn(Schedulers.computation());
-        
+
         // now try and generate a hang by zipping src with itself repeatedly. A
         // time limit of 9 seconds ( 1 second less than the test timeout) is
         // used so that this test will not timeout on slow machines.
@@ -1322,11 +1322,11 @@ public Integer call(Integer t1, Integer t2) {
                     return t1 + t2 * 10;
                 }
             }).toBlocking().singleOrDefault(0);
-            
+
             Assert.assertEquals(11, value);
         }
     }
-    /** 
+    /**
      * Request only a single value and don't wait for another request just
      * to emit an onCompleted.
      */
@@ -1339,28 +1339,28 @@ public void onStart() {
                 requestMore(1);
             }
         };
-        
+
         Observable.zip(src, src, new Func2<Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2) {
                 return t1 + t2 * 10;
             }
         }).subscribe(ts);
-        
+
         ts.awaitTerminalEvent(1, TimeUnit.SECONDS);
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(11));
     }
-    
+
     @SuppressWarnings("cast")
     @Test
     public void testZipObservableObservableBackpressure() {
         @SuppressWarnings("unchecked")
-        Observable<Integer>[] osArray = new Observable[] { 
-                Observable.range(0, 10), 
-                Observable.range(0, 10) 
+        Observable<Integer>[] osArray = new Observable[] {
+                Observable.range(0, 10),
+                Observable.range(0, 10)
         };
-        
+
         Observable<Observable<Integer>> os = (Observable<Observable<Integer>>) Observable.from(osArray);
         Observable<Integer> o1 = Observable.zip(os, new FuncN<Integer>() {
             @Override
@@ -1368,9 +1368,9 @@ public Integer call(Object... a) {
                 return 0;
             }
         });
-        
+
         TestSubscriber<Integer> sub1 = TestSubscriber.create(5);
-        
+
         o1.subscribe(sub1);
 
         sub1.requestMore(5);
@@ -1379,13 +1379,13 @@ public Integer call(Object... a) {
         sub1.assertNoErrors();
         sub1.assertCompleted();
     }
-    
+
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @Test
     public void zip4() {
         TestSubscriber<String> ts = TestSubscriber.create();
         Observable<Integer> source = Observable.just(1);
-        
+
         Observable.zip(source, source, source, source, new Func4() {
             @Override
             public Object call(Object t1, Object t2, Object t3, Object t4) {
@@ -1393,18 +1393,18 @@ public Object call(Object t1, Object t2, Object t3, Object t4) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue("1111");
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @Test
     public void zip5() {
         TestSubscriber<String> ts = TestSubscriber.create();
         Observable<Integer> source = Observable.just(1);
-        
+
         Observable.zip(source, source, source, source, source, new Func5() {
             @Override
             public Object call(Object t1, Object t2, Object t3, Object t4, Object t5) {
@@ -1412,18 +1412,18 @@ public Object call(Object t1, Object t2, Object t3, Object t4, Object t5) {
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue("11111");
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @Test
     public void zip6() {
         TestSubscriber<String> ts = TestSubscriber.create();
         Observable<Integer> source = Observable.just(1);
-        
+
         Observable.zip(source, source, source, source, source, source, new Func6() {
             @Override
             public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6) {
@@ -1431,7 +1431,7 @@ public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, Object
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue("111111");
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -1442,7 +1442,7 @@ public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, Object
     public void zip7() {
         TestSubscriber<String> ts = TestSubscriber.create();
         Observable<Integer> source = Observable.just(1);
-        
+
         Observable.zip(source, source, source, source, source, source, source, new Func7() {
             @Override
             public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7) {
@@ -1450,18 +1450,18 @@ public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, Object
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue("1111111");
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @Test
     public void zip8() {
         TestSubscriber<String> ts = TestSubscriber.create();
         Observable<Integer> source = Observable.just(1);
-        
+
         Observable.zip(source, source, source, source, source, source, source, source, new Func8() {
             @Override
             public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7, Object t8) {
@@ -1469,27 +1469,27 @@ public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, Object
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue("11111111");
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings({ "unchecked", "rawtypes" })
     @Test
     public void zip9() {
         TestSubscriber<String> ts = TestSubscriber.create();
         Observable<Integer> source = Observable.just(1);
-        
+
         Observable.zip(source, source, source, source, source, source, source, source, source, new Func9() {
             @Override
-            public Object call(Object t1, Object t2, Object t3, Object t4, Object t5, 
+            public Object call(Object t1, Object t2, Object t3, Object t4, Object t5,
                     Object t6, Object t7, Object t8, Object t9) {
                 return "" + t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8 + t9;
             }
         })
         .subscribe(ts);
-        
+
         ts.assertValue("111111111");
         ts.assertNoErrors();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/SafeSubscriberTest.java b/src/test/java/rx/internal/operators/SafeSubscriberTest.java
index 43ad503f79..8cd7c18031 100644
--- a/src/test/java/rx/internal/operators/SafeSubscriberTest.java
+++ b/src/test/java/rx/internal/operators/SafeSubscriberTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/operators/SingleDoAfterTerminateTest.java b/src/test/java/rx/internal/operators/SingleDoAfterTerminateTest.java
index be2ab6fb5d..e1df07579a 100644
--- a/src/test/java/rx/internal/operators/SingleDoAfterTerminateTest.java
+++ b/src/test/java/rx/internal/operators/SingleDoAfterTerminateTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2015 Netflix, Inc.
- * 
+ *
  * 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.
@@ -29,7 +29,7 @@ public class SingleDoAfterTerminateTest {
     public void chainedCallsOuter() {
         for (int i = 2; i <= 5; i++) {
             final AtomicInteger counter = new AtomicInteger();
-            
+
             Single<String> source = Single.just("Test")
             .flatMap(new Func1<String, Single<String>>() {
                 @Override
@@ -54,21 +54,21 @@ public void call() {
                     }
                 });
             }
-            
+
             result
             .subscribe(new TestSubscriber<String>());
-            
+
             Assert.assertEquals(i, counter.get());
         }
     }
-    
+
     @Test
     public void chainedCallsInner() {
         for (int i = 2; i <= 5; i++) {
             final AtomicInteger counter = new AtomicInteger();
-            
+
             final int fi = i;
-            
+
             Single.just("Test")
             .flatMap(new Func1<String, Single<String>>() {
                 @Override
@@ -92,7 +92,7 @@ public void call() {
                 }
             })
             .subscribe(new TestSubscriber<String>());
-            
+
             Assert.assertEquals(i, counter.get());
         }
     }
diff --git a/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java b/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java
index 96fd9ab05e..f03d5cf5c1 100644
--- a/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java
+++ b/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -33,7 +33,7 @@ public class SingleOnSubscribeUsingTest {
 
     private interface Resource {
         String getTextFromWeb();
-        
+
         void dispose();
     }
 
@@ -318,15 +318,15 @@ public Single<String> call(Resource resource) {
 
     }
 
-    
-    
+
+
     @Test
     public void disposesEagerlyBeforeError() {
         final List<String> events = new ArrayList<String>();
         Func0<Resource> resourceFactory = createResourceFactory(events);
         final Action1<Throwable> onError = createOnErrorAction(events);
         final Action0 unsub = createUnsubAction(events);
-        
+
         Func1<Resource, Single<String>> observableFactory = new Func1<Resource, Single<String>>() {
             @Override
             public Single<String> call(Resource resource) {
@@ -344,14 +344,14 @@ public Single<String> call(Resource resource) {
         assertEquals(Arrays.asList("disposed", "error", "unsub"), events);
 
     }
-    
+
     @Test
     public void doesNotDisposesEagerlyBeforeError() {
         final List<String> events = new ArrayList<String>();
         Func0<Resource> resourceFactory = createResourceFactory(events);
         final Action1<Throwable> onError = createOnErrorAction(events);
         final Action0 unsub = createUnsubAction(events);
-        
+
         Func1<Resource, Single<String>> observableFactory = new Func1<Resource, Single<String>>() {
             @Override
             public Single<String> call(Resource resource) {
@@ -406,7 +406,7 @@ public void dispose() {
             }
         };
     }
-    
+
     private static Action1<String> createOnSuccessAction(final List<String> events) {
         return new Action1<String>() {
             @Override
@@ -431,7 +431,7 @@ public Single<String> call(Resource resource) {
 
             Single.using(null, observableFactory,
                     new DisposeAction(), false);
-            
+
             fail("Failed to throw NullPointerException");
         } catch (NullPointerException ex) {
             assertEquals("resourceFactory is null", ex.getMessage());
@@ -453,7 +453,7 @@ public Resource call() {
 
             Single.using(resourceFactory, null,
                     new DisposeAction(), false);
-            
+
             fail("Failed to throw NullPointerException");
         } catch (NullPointerException ex) {
             assertEquals("singleFactory is null", ex.getMessage());
@@ -482,7 +482,7 @@ public Single<String> call(Resource resource) {
 
             Single.using(resourceFactory, observableFactory,
                     null, false);
-            
+
             fail("Failed to throw NullPointerException");
         } catch (NullPointerException ex) {
             assertEquals("disposeAction is null", ex.getMessage());
diff --git a/src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java b/src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java
index 02c2f18c34..e1008befe8 100644
--- a/src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java
+++ b/src/test/java/rx/internal/producers/ProducerObserverArbiterTest.java
@@ -182,14 +182,14 @@ public void onNext(Integer t) {
         }
         assertEquals(1, poa.requested);
     }
-    
+
     @Test
     public void requestIsCapped() {
         ProducerObserverArbiter<Integer> poa = new ProducerObserverArbiter<Integer>(new TestSubscriber<Integer>());
-    
+
         poa.request(Long.MAX_VALUE - 1);
         poa.request(2);
-        
+
         assertEquals(Long.MAX_VALUE, Long.MAX_VALUE);
     }
 
diff --git a/src/test/java/rx/internal/producers/ProducersTest.java b/src/test/java/rx/internal/producers/ProducersTest.java
index e482bec8a8..f41fcda71a 100644
--- a/src/test/java/rx/internal/producers/ProducersTest.java
+++ b/src/test/java/rx/internal/producers/ProducersTest.java
@@ -40,7 +40,7 @@ public void testSingleNoBackpressure() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         SingleProducer<Integer> sp = new SingleProducer<Integer>(ts, 1);
         ts.setProducer(sp);
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList(1));
@@ -51,18 +51,18 @@ public void testSingleWithBackpressure() {
         ts.requestMore(0);
         SingleProducer<Integer> sp = new SingleProducer<Integer>(ts, 1);
         ts.setProducer(sp);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
         Assert.assertEquals(0, ts.getCompletions());
-        
+
         ts.requestMore(2);
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList(1));
     }
-    
+
     @Test
     public void testSingleDelayedNoBackpressure() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -72,15 +72,15 @@ public void testSingleDelayedNoBackpressure() {
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
         Assert.assertEquals(0, ts.getCompletions());
-        
+
         sdp.setValue(1);
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList(1));
 
         sdp.setValue(2);
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1));
     }
     @Test
@@ -93,32 +93,32 @@ public void testSingleDelayedWithBackpressure() {
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
         Assert.assertEquals(0, ts.getCompletions());
-        
+
         sdp.setValue(1);
 
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
         Assert.assertEquals(0, ts.getCompletions());
-        
+
         ts.requestMore(2);
-        
+
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList(1));
 
         sdp.setValue(2);
-        
+
         ts.assertReceivedOnNext(Arrays.asList(1));
     }
-    
+
     @Test
     public void testQueuedValueNoBackpressure() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         QueuedValueProducer<Integer> qvp = new QueuedValueProducer<Integer>(ts);
         ts.setProducer(qvp);
-        
+
         qvp.offer(1);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1));
 
@@ -137,35 +137,35 @@ public void testQueuedValueWithBackpressure() {
         ts.setProducer(qvp);
 
         qvp.offer(1);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
-        
+
         qvp.offer(2);
         ts.requestMore(2);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2));
-        
+
         ts.requestMore(2);
 
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2));
-        
+
         qvp.offer(3);
         qvp.offer(4);
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4));
     }
-    
+
     @Test
     public void testQueuedNoBackpressure() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         QueuedProducer<Integer> qp = new QueuedProducer<Integer>(ts);
         ts.setProducer(qp);
-        
+
         qp.offer(1);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1));
 
@@ -175,9 +175,9 @@ public void testQueuedNoBackpressure() {
 
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4));
-        
+
         qp.onCompleted();
-        
+
         ts.assertTerminalEvent();
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4));
@@ -190,52 +190,52 @@ public void testQueuedWithBackpressure() {
         ts.setProducer(qp);
 
         qp.offer(1);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Collections.<Integer>emptyList());
-        
+
         qp.offer(2);
         ts.requestMore(2);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2));
-        
+
         ts.requestMore(2);
 
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2));
-        
+
         qp.offer(3);
         qp.offer(4);
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4));
-        
+
         qp.onCompleted();
         ts.assertTerminalEvent();
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4));
     }
-    
+
     @Test
     public void testArbiter() {
         Producer p1 = mock(Producer.class);
         Producer p2 = mock(Producer.class);
-        
+
         ProducerArbiter pa = new ProducerArbiter();
-        
+
         pa.request(100);
-        
+
         pa.setProducer(p1);
-        
+
         verify(p1).request(100);
-        
+
         pa.produced(50);
-        
+
         pa.setProducer(p2);
-        
+
         verify(p2).request(50);
     }
-    
+
     static final class TestProducer implements Producer {
         final Observer<Integer> child;
         public TestProducer(Observer<Integer> child) {
@@ -246,7 +246,7 @@ public void request(long n) {
             child.onNext((int)n);
         }
     }
-    
+
     @Test
     public void testObserverArbiterWithBackpressure() {
         final TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -254,11 +254,11 @@ public void testObserverArbiterWithBackpressure() {
         final ProducerObserverArbiter<Integer> poa = new ProducerObserverArbiter<Integer>(ts);
         ts.setProducer(poa);
 
-        
+
         poa.setProducer(new TestProducer(poa));
 
         ts.requestMore(1);
-        
+
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1));
 
@@ -272,20 +272,20 @@ public void testObserverArbiterWithBackpressure() {
 
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(1, 5));
-        
+
         poa.onCompleted();
         ts.assertNoErrors();
         ts.assertTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList(1, 5));
     }
-    static final class SwitchTimer<T> 
+    static final class SwitchTimer<T>
     implements OnSubscribe<T> {
         final List<Observable<? extends T>> sources;
         final long time;
         final TimeUnit unit;
         final Scheduler scheduler;
         public SwitchTimer(
-                Iterable<? extends Observable<? extends T>> sources, 
+                Iterable<? extends Observable<? extends T>> sources,
                 long time, TimeUnit unit, Scheduler scheduler) {
             this.scheduler = scheduler;
             this.sources = new ArrayList<Observable<? extends T>>();
@@ -297,19 +297,19 @@ public SwitchTimer(
         }
         @Override
         public void call(Subscriber<? super T> child) {
-            final ProducerObserverArbiter<T> poa = 
+            final ProducerObserverArbiter<T> poa =
                 new ProducerObserverArbiter<T>(child);
-             
+
             Scheduler.Worker w = scheduler.createWorker();
             child.add(w);
-             
+
             child.setProducer(poa);
-             
+
             final SerialSubscription ssub = new SerialSubscription();
             child.add(ssub);
-             
+
             final int[] index = new int[1];
-             
+
             w.schedulePeriodically(new Action0() {
                 @Override
                 public void call() {
@@ -338,7 +338,7 @@ public void setProducer(Producer producer) {
                             poa.setProducer(producer);
                         }
                     };
-         
+
                     ssub.set(s);
                     sources.get(idx).unsafeSubscribe(s);
                 }
@@ -364,24 +364,24 @@ public void testObserverArbiterAsync() {
             Observable.interval(100, 100, TimeUnit.MILLISECONDS, test)
                 .map(plus(40))
         );
-         
+
         Observable<Long> source = Observable.create(
-            new SwitchTimer<Long>(timers, 550, 
+            new SwitchTimer<Long>(timers, 550,
             TimeUnit.MILLISECONDS, test));
-                 
+
         TestSubscriber<Long> ts = new TestSubscriber<Long>();
         ts.requestMore(100);
         source.subscribe(ts);
-            
+
         test.advanceTimeBy(1, TimeUnit.MINUTES);
-        
+
         ts.assertTerminalEvent();
         ts.assertNoErrors();
         ts.assertReceivedOnNext(Arrays.asList(0L, 1L, 2L, 3L, 4L,
                 20L, 21L, 22L, 23L, 24L,
                 40L, 41L, 42L, 43L, 44L));
     }
-    
+
     @Test(timeout = 1000)
     public void testProducerObserverArbiterUnbounded() {
         Observable.range(0, Integer.MAX_VALUE)
@@ -389,7 +389,7 @@ public void testProducerObserverArbiterUnbounded() {
             @Override
             public Subscriber<? super Integer> call(Subscriber<? super Integer> t) {
                 final ProducerObserverArbiter<Integer> poa = new ProducerObserverArbiter<Integer>(t);
-                
+
                 Subscriber<Integer> parent = new Subscriber<Integer>() {
 
                     @Override
@@ -406,17 +406,17 @@ public void onError(Throwable e) {
                     public void onNext(Integer t) {
                         poa.onNext(t);
                     }
-                    
-                    
+
+
                     @Override
                     public void setProducer(Producer p) {
                         poa.setProducer(p);
                     }
                 };
-                
+
                 t.add(parent);
                 t.setProducer(poa);
-                
+
                 return parent;
             }
         }).subscribe(new TestSubscriber<Integer>() {
@@ -429,7 +429,7 @@ public void onNext(Integer t) {
             }
         });
     }
-    
+
     @Test
     public void queuedProducerRequestNegative() {
         QueuedProducer<Integer> qp = new QueuedProducer<Integer>(new TestSubscriber<Integer>());
@@ -445,9 +445,9 @@ public void queuedProducerOfferNull() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
         QueuedProducer<Integer> qp = new QueuedProducer<Integer>(ts);
         qp.offer(null);
-        
+
         qp.request(1);
-        
+
         ts.assertValue(null);
     }
 
@@ -457,9 +457,9 @@ public void queuedProducerFull() {
         QueuedProducer<Integer> qp = new QueuedProducer<Integer>(ts, new SpscArrayQueue<Object>(1));
         assertTrue(qp.offer(1));
         assertFalse(qp.offer(2));
-        
+
         qp.request(1);
-        
+
         ts.assertValue(1);
     }
 
@@ -470,9 +470,9 @@ public void queuedProducerOnNextFull() {
 
         qp.onNext(1);
         qp.onNext(2);
-        
+
         qp.request(1);
-        
+
         ts.assertError(MissingBackpressureException.class);
     }
 
@@ -483,9 +483,9 @@ public void queuedProducerOnNextFullWithNull() {
 
         qp.onNext(1);
         qp.onNext(null);
-        
+
         qp.request(1);
-        
+
         ts.assertError(MissingBackpressureException.class);
     }
 
@@ -496,9 +496,9 @@ public void queuedProducerRequestCompletes() {
 
         qp.onNext(1);
         qp.onCompleted();
-        
+
         qp.request(2);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -512,9 +512,9 @@ public void queuedProducerUnsubscribed() {
 
         qp.onNext(1);
         qp.onCompleted();
-        
+
         qp.request(2);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
diff --git a/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java b/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
index 9411b9909e..d3e074df04 100644
--- a/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
+++ b/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
@@ -47,11 +47,11 @@ public void requestCompleteRace() throws Exception {
                 final AtomicInteger waiter = new AtomicInteger(2);
 
                 TestSubscriber<Integer> ts = TestSubscriber.create();
-                
+
                 final SingleDelayedProducer<Integer> pa = new SingleDelayedProducer<Integer>(ts);
 
                 final CountDownLatch cdl = new CountDownLatch(1);
-                
+
                 w.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -61,14 +61,14 @@ public void call() {
                         cdl.countDown();
                     }
                 });
-                
+
                 waiter.decrementAndGet();
                 while (waiter.get() != 0) ;
                 pa.setValue(1);
                 if (!cdl.await(5, TimeUnit.SECONDS)) {
                     Assert.fail("The wait for completion timed out");
                 }
-                
+
                 ts.assertValue(1);
                 ts.assertCompleted();
             }
diff --git a/src/test/java/rx/internal/producers/SingleProducerTest.java b/src/test/java/rx/internal/producers/SingleProducerTest.java
index 48cda1ef16..1f63e289ec 100644
--- a/src/test/java/rx/internal/producers/SingleProducerTest.java
+++ b/src/test/java/rx/internal/producers/SingleProducerTest.java
@@ -39,11 +39,11 @@ public void negativeRequestThrows() {
     public void cancelBeforeOnNext() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         SingleProducer<Integer> pa = new SingleProducer<Integer>(ts, 1);
-        
+
         ts.unsubscribe();
-        
+
         pa.request(1);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
@@ -53,7 +53,7 @@ public void cancelBeforeOnNext() {
     public void cancelAfterOnNext() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         Observable.just(1).take(1).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -68,9 +68,9 @@ public void onNext(Integer t) {
             }
         };
         SingleProducer<Integer> sp = new SingleProducer<Integer>(ts, 1);
-        
+
         sp.request(1);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
diff --git a/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java b/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java
index a4f419f044..3c6b85255a 100644
--- a/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java
+++ b/src/test/java/rx/internal/schedulers/ExecutorSchedulerTest.java
@@ -33,7 +33,7 @@
 public class ExecutorSchedulerTest extends AbstractSchedulerConcurrencyTests {
 
     final static Executor executor = Executors.newFixedThreadPool(2, new RxThreadFactory("TestCustomPool-"));
-    
+
     @Override
     protected Scheduler getScheduler() {
         return Schedulers.from(executor);
@@ -48,7 +48,7 @@ public final void testUnhandledErrorIsDeliveredToThreadHandler() throws Interrup
     public final void testHandledErrorIsNotDeliveredToThreadHandler() throws InterruptedException {
         SchedulerTests.testHandledErrorIsNotDeliveredToThreadHandler(getScheduler());
     }
-    
+
     @Test(timeout = 60000)
     public void testCancelledTaskRetention() throws InterruptedException {
         ExecutorService exec = Executors.newSingleThreadExecutor();
@@ -60,7 +60,7 @@ public void testCancelledTaskRetention() throws InterruptedException {
             } finally {
                 w.unsubscribe();
             }
-            
+
             w = s.createWorker();
             try {
                 SchedulerTests.testCancelledRetention(w, true);
@@ -71,7 +71,7 @@ public void testCancelledTaskRetention() throws InterruptedException {
             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<Runnable> queue = new ConcurrentLinkedQueue<Runnable>();
@@ -92,7 +92,7 @@ public void executeAll() {
             }
         }
     }
-    
+
     @Test
     public void testCancelledTasksDontRun() {
         final AtomicInteger calls = new AtomicInteger();
@@ -109,13 +109,13 @@ public void call() {
             Subscription s1 = w.schedule(task);
             Subscription s2 = w.schedule(task);
             Subscription s3 = w.schedule(task);
-            
+
             s1.unsubscribe();
             s2.unsubscribe();
             s3.unsubscribe();
-            
+
             exec.executeAll();
-            
+
             assertEquals(0, calls.get());
         } finally {
             w.unsubscribe();
@@ -152,35 +152,35 @@ public void execute(Runnable command) {
             }
         };
         ExecutorSchedulerWorker w = (ExecutorSchedulerWorker)Schedulers.from(e).createWorker();
-        
+
         w.schedule(Actions.empty(), 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) {
-                
+
             }
         };
         ExecutorSchedulerWorker w = (ExecutorSchedulerWorker)Schedulers.from(e).createWorker();
-        
+
         Subscription s = w.schedule(Actions.empty(), 1, TimeUnit.DAYS);
-        
+
         assertTrue(w.tasks.hasSubscriptions());
-        
+
         s.unsubscribe();
-        
+
         assertFalse(w.tasks.hasSubscriptions());
     }
-    
+
     @Test
     public void testNoPeriodicTimedTaskPartRetention() throws InterruptedException {
         Executor e = new Executor() {
@@ -190,7 +190,7 @@ public void execute(Runnable command) {
             }
         };
         ExecutorSchedulerWorker w = (ExecutorSchedulerWorker)Schedulers.from(e).createWorker();
-        
+
         final CountDownLatch cdl = new CountDownLatch(1);
         final Action0 action = new Action0() {
             @Override
@@ -198,24 +198,24 @@ public void call() {
                 cdl.countDown();
             }
         };
-        
+
         Subscription s = w.schedulePeriodically(action, 0, 1, TimeUnit.DAYS);
-        
+
         assertTrue(w.tasks.hasSubscriptions());
-        
+
         cdl.await();
-        
+
         s.unsubscribe();
-        
+
         assertFalse(w.tasks.hasSubscriptions());
     }
-    
+
     @Test
     public void actionHookCalled() throws Exception {
         ExecutorService exec = Executors.newSingleThreadExecutor();
         try {
             final int[] call = { 0 };
-            
+
             RxJavaHooks.setOnScheduleAction(new Func1<Action0, Action0>() {
                 @Override
                 public Action0 call(Action0 t) {
@@ -223,13 +223,13 @@ public Action0 call(Action0 t) {
                     return t;
                 }
             });
-            
+
             Scheduler s = Schedulers.from(exec);
-            
+
             Worker w = s.createWorker();
-            
+
             final CountDownLatch cdl = new CountDownLatch(1);
-            
+
             try {
                 w.schedule(new Action0() {
                     @Override
@@ -237,12 +237,12 @@ public void call() {
                         cdl.countDown();
                     }
                 });
-                
+
                 Assert.assertTrue("Action timed out", cdl.await(5, TimeUnit.SECONDS));
             } finally {
                 w.unsubscribe();
             }
-            
+
             Assert.assertEquals("Hook not called!", 1, call[0]);
         } finally {
             RxJavaHooks.reset();
diff --git a/src/test/java/rx/internal/schedulers/GenericScheduledExecutorServiceTest.java b/src/test/java/rx/internal/schedulers/GenericScheduledExecutorServiceTest.java
index 6bb8800c97..eef6d293d9 100644
--- a/src/test/java/rx/internal/schedulers/GenericScheduledExecutorServiceTest.java
+++ b/src/test/java/rx/internal/schedulers/GenericScheduledExecutorServiceTest.java
@@ -25,12 +25,12 @@ public class GenericScheduledExecutorServiceTest {
     @Test
     public void verifyInstanceIsSingleThreaded() throws Exception {
         ScheduledExecutorService exec = GenericScheduledExecutorService.getInstance();
-        
+
         final AtomicInteger state = new AtomicInteger();
 
         final AtomicInteger found1 = new AtomicInteger();
         final AtomicInteger found2 = new AtomicInteger();
-        
+
         Future<?> f1 = exec.schedule(new Runnable() {
             @Override
             public void run() {
@@ -48,10 +48,10 @@ public void run() {
                 found2.set(state.getAndSet(2));
             }
         }, 250, TimeUnit.MILLISECONDS);
-        
+
         f1.get();
         f2.get();
-        
+
         Assert.assertEquals(2, state.get());
         Assert.assertEquals(0, found1.get());
         Assert.assertEquals(1, found2.get());
diff --git a/src/test/java/rx/internal/util/BlockingUtilsTest.java b/src/test/java/rx/internal/util/BlockingUtilsTest.java
index 02047b9d2f..007a2eb737 100644
--- a/src/test/java/rx/internal/util/BlockingUtilsTest.java
+++ b/src/test/java/rx/internal/util/BlockingUtilsTest.java
@@ -31,14 +31,14 @@
  * Test suite for {@link BlockingUtils}.
  */
 public class BlockingUtilsTest {
-    
+
     @Before
     @After
     public void before() {
         // make sure the interrupted flag is cleared
         Thread.interrupted();
     }
-    
+
     @Test
     public void awaitCompleteShouldReturnIfCountIsZero() {
         Subscription subscription = mock(Subscription.class);
diff --git a/src/test/java/rx/internal/util/ExceptionUtilsTest.java b/src/test/java/rx/internal/util/ExceptionUtilsTest.java
index 16caa06deb..6f46325158 100644
--- a/src/test/java/rx/internal/util/ExceptionUtilsTest.java
+++ b/src/test/java/rx/internal/util/ExceptionUtilsTest.java
@@ -47,13 +47,13 @@ public void isTerminated() {
 
         Assert.assertFalse(ExceptionsUtils.isTerminated(error));
         Assert.assertFalse(ExceptionsUtils.isTerminated(error.get()));
-        
+
         ExceptionsUtils.terminate(error);
-        
+
         Assert.assertTrue(ExceptionsUtils.isTerminated(error));
         Assert.assertTrue(ExceptionsUtils.isTerminated(error.get()));
     }
-    
+
     @Test
     public void utilityEnum() {
         assertEquals(0, ExceptionsUtils.values().length);
diff --git a/src/test/java/rx/internal/util/IndexedRingBufferTest.java b/src/test/java/rx/internal/util/IndexedRingBufferTest.java
index 5417693b85..5ed75ea5e5 100644
--- a/src/test/java/rx/internal/util/IndexedRingBufferTest.java
+++ b/src/test/java/rx/internal/util/IndexedRingBufferTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/util/JCToolsQueueTests.java b/src/test/java/rx/internal/util/JCToolsQueueTests.java
index 7f554993ab..1ec3c202bb 100644
--- a/src/test/java/rx/internal/util/JCToolsQueueTests.java
+++ b/src/test/java/rx/internal/util/JCToolsQueueTests.java
@@ -47,17 +47,17 @@ public void casBasedUnsafe() {
         }
         long offset = UnsafeAccess.addressOf(IntField.class, "value");
         IntField f = new IntField();
-        
+
         assertTrue(UnsafeAccess.compareAndSwapInt(f, offset, 0, 1));
         assertFalse(UnsafeAccess.compareAndSwapInt(f, offset, 0, 2));
-        
+
         assertEquals(1, UnsafeAccess.getAndAddInt(f, offset, 2));
-        
+
         assertEquals(3, UnsafeAccess.getAndIncrementInt(f, offset));
-        
+
         assertEquals(4, UnsafeAccess.getAndSetInt(f, offset, 0));
     }
-    
+
     @Test
     public void powerOfTwo() {
         assertTrue(Pow2.isPowerOfTwo(1));
@@ -72,7 +72,7 @@ public void powerOfTwo() {
         assertFalse(Pow2.isPowerOfTwo(31));
         assertTrue(Pow2.isPowerOfTwo(32));
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void testMpmcArrayQueueNull() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
@@ -81,7 +81,7 @@ public void testMpmcArrayQueueNull() {
         MpmcArrayQueue<Integer> q = new MpmcArrayQueue<Integer>(16);
         q.offer(null);
     }
-    
+
     @Test(expected = UnsupportedOperationException.class)
     public void testMpmcArrayQueueIterator() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
@@ -90,17 +90,17 @@ public void testMpmcArrayQueueIterator() {
         MpmcArrayQueue<Integer> q = new MpmcArrayQueue<Integer>(16);
         q.iterator();
     }
-    
+
     @Test
     public void testMpmcArrayQueueOfferPoll() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
             return;
         }
         Queue<Integer> q = new MpmcArrayQueue<Integer>(128);
-        
+
         testOfferPoll(q);
     }
-    
+
     @Test
     public void testMpmcOfferUpToCapacity() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
@@ -118,31 +118,31 @@ public void testMpscLinkedAtomicQueueIterator() {
         MpscLinkedAtomicQueue<Integer> q = new MpscLinkedAtomicQueue<Integer>();
         q.iterator();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void testMpscLinkedAtomicQueueNull() {
         MpscLinkedAtomicQueue<Integer> q = new MpscLinkedAtomicQueue<Integer>();
         q.offer(null);
     }
-    
+
     @Test
     public void testMpscLinkedAtomicQueueOfferPoll() {
         MpscLinkedAtomicQueue<Integer> q = new MpscLinkedAtomicQueue<Integer>();
-        
+
         testOfferPoll(q);
     }
-    
+
     @Test(timeout = 20000)
     public void testMpscLinkedAtomicQueuePipelined() throws InterruptedException {
         final MpscLinkedAtomicQueue<Integer> q = new MpscLinkedAtomicQueue<Integer>();
-        
+
         Set<Integer> set = new HashSet<Integer>();
         for (int i = 0; i < 1000 * 1000; i++) {
             set.add(i);
         }
-        
+
         final CyclicBarrier cb = new CyclicBarrier(3);
-        
+
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
@@ -161,12 +161,12 @@ public void run() {
                 }
             }
         });
-        
+
         t1.start();
         t2.start();
-        
+
         await(cb);
-        
+
         Integer j;
         for (int i = 0; i < 1000 * 1000; i++) {
             while ((j = q.poll()) == null);
@@ -174,7 +174,7 @@ public void run() {
         }
         assertTrue("Set is not empty", set.isEmpty());
     }
-    
+
     @Test(expected = UnsupportedOperationException.class)
     public void testMpscLinkedQueueIterator() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
@@ -183,7 +183,7 @@ public void testMpscLinkedQueueIterator() {
         MpscLinkedQueue<Integer> q = new MpscLinkedQueue<Integer>();
         q.iterator();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void testMpscLinkedQueueNull() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
@@ -192,14 +192,14 @@ public void testMpscLinkedQueueNull() {
         MpscLinkedQueue<Integer> q = new MpscLinkedQueue<Integer>();
         q.offer(null);
     }
-    
+
     @Test
     public void testMpscLinkedQueueOfferPoll() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
             return;
         }
         MpscLinkedQueue<Integer> q = new MpscLinkedQueue<Integer>();
-        
+
         testOfferPoll(q);
     }
     @Test(timeout = 20000)
@@ -208,14 +208,14 @@ public void testMpscLinkedQueuePipelined() throws InterruptedException {
             return;
         }
         final MpscLinkedQueue<Integer> q = new MpscLinkedQueue<Integer>();
-        
+
         Set<Integer> set = new HashSet<Integer>();
         for (int i = 0; i < 1000 * 1000; i++) {
             set.add(i);
         }
-        
+
         final CyclicBarrier cb = new CyclicBarrier(3);
-        
+
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
@@ -234,12 +234,12 @@ public void run() {
                 }
             }
         });
-        
+
         t1.start();
         t2.start();
-        
+
         await(cb);
-        
+
         Integer j;
         for (int i = 0; i < 1000 * 1000; i++) {
             while ((j = q.poll()) == null);
@@ -247,7 +247,7 @@ public void run() {
         }
         assertTrue("Set is not empty", set.isEmpty());
     }
-    
+
     protected void testOfferPoll(Queue<Integer> q) {
         for (int i = 0; i < 64; i++) {
             assertTrue(q.offer(i));
@@ -255,23 +255,23 @@ protected void testOfferPoll(Queue<Integer> q) {
         assertFalse(q.isEmpty());
         for (int i = 0; i < 64; i++) {
             assertEquals((Integer)i, q.peek());
-            
+
             assertEquals(64 - i, q.size());
-            
+
             assertEquals((Integer)i, q.poll());
         }
         assertTrue(q.isEmpty());
-        
+
         for (int i = 0; i < 64; i++) {
             assertTrue(q.offer(i));
             assertEquals((Integer)i, q.poll());
         }
-        
+
         assertTrue(q.isEmpty());
         assertNull(q.peek());
         assertNull(q.poll());
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void testSpmcArrayQueueNull() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
@@ -280,14 +280,14 @@ public void testSpmcArrayQueueNull() {
         SpmcArrayQueue<Integer> q = new SpmcArrayQueue<Integer>(16);
         q.offer(null);
     }
-    
+
     @Test
     public void testSpmcArrayQueueOfferPoll() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
             return;
         }
         Queue<Integer> q = new SpmcArrayQueue<Integer>(128);
-        
+
         testOfferPoll(q);
     }
     @Test(expected = UnsupportedOperationException.class)
@@ -298,7 +298,7 @@ public void testSpmcArrayQueueIterator() {
         SpmcArrayQueue<Integer> q = new SpmcArrayQueue<Integer>(16);
         q.iterator();
     }
-    
+
     @Test
     public void testSpmcOfferUpToCapacity() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
@@ -311,7 +311,7 @@ public void testSpmcOfferUpToCapacity() {
         }
         assertFalse(queue.offer(n));
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void testSpscArrayQueueNull() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
@@ -320,14 +320,14 @@ public void testSpscArrayQueueNull() {
         SpscArrayQueue<Integer> q = new SpscArrayQueue<Integer>(16);
         q.offer(null);
     }
-    
+
     @Test
     public void testSpscArrayQueueOfferPoll() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
             return;
         }
         Queue<Integer> q = new SpscArrayQueue<Integer>(128);
-        
+
         testOfferPoll(q);
     }
     @Test(expected = UnsupportedOperationException.class)
@@ -348,19 +348,19 @@ public void testSpscLinkedAtomicQueueNull() {
         SpscLinkedAtomicQueue<Integer> q = new SpscLinkedAtomicQueue<Integer>();
         q.offer(null);
     }
-    
+
     @Test
     public void testSpscLinkedAtomicQueueOfferPoll() {
         SpscLinkedAtomicQueue<Integer> q = new SpscLinkedAtomicQueue<Integer>();
-        
+
         testOfferPoll(q);
     }
-    
+
     @Test(timeout = 20000)
     public void testSpscLinkedAtomicQueuePipelined() throws InterruptedException {
         final SpscLinkedAtomicQueue<Integer> q = new SpscLinkedAtomicQueue<Integer>();
         final AtomicInteger count = new AtomicInteger();
-        
+
         Thread t = new Thread(new Runnable() {
             @Override
             public void run() {
@@ -374,15 +374,15 @@ public void run() {
             }
         });
         t.start();
-        
+
         for (int i = 0; i < 1000 * 1000; i++) {
             assertTrue(q.offer(i));
         }
         t.join();
-        
+
         assertEquals(1000 * 1000, count.get());
     }
-    
+
     @Test(expected = UnsupportedOperationException.class)
     public void testSpscLinkedQueueIterator() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
@@ -391,7 +391,7 @@ public void testSpscLinkedQueueIterator() {
         SpscLinkedQueue<Integer> q = new SpscLinkedQueue<Integer>();
         q.iterator();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void testSpscLinkedQueueNull() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
@@ -400,17 +400,17 @@ public void testSpscLinkedQueueNull() {
         SpscLinkedQueue<Integer> q = new SpscLinkedQueue<Integer>();
         q.offer(null);
     }
-    
+
     @Test
     public void testSpscLinkedQueueOfferPoll() {
         if (!UnsafeAccess.isUnsafeAvailable()) {
             return;
         }
         SpscLinkedQueue<Integer> q = new SpscLinkedQueue<Integer>();
-        
+
         testOfferPoll(q);
     }
-    
+
     @Test(timeout = 20000)
     public void testSpscLinkedQueuePipelined() throws InterruptedException {
         if (!UnsafeAccess.isUnsafeAvailable()) {
@@ -418,7 +418,7 @@ public void testSpscLinkedQueuePipelined() throws InterruptedException {
         }
         final SpscLinkedQueue<Integer> q = new SpscLinkedQueue<Integer>();
         final AtomicInteger count = new AtomicInteger();
-        
+
         Thread t = new Thread(new Runnable() {
             @Override
             public void run() {
@@ -432,12 +432,12 @@ public void run() {
             }
         });
         t.start();
-        
+
         for (int i = 0; i < 1000 * 1000; i++) {
             assertTrue(q.offer(i));
         }
         t.join();
-        
+
         assertEquals(1000 * 1000, count.get());
     }
 
@@ -461,23 +461,23 @@ public void testUnsafeAccessAddressOf() {
         }
         UnsafeAccess.addressOf(Object.class, "field");
     }
-    
+
     @Test
     public void testSpscExactAtomicArrayQueue() {
         for (int i = 1; i <= RxRingBuffer.SIZE * 2; i++) {
             SpscExactAtomicArrayQueue<Integer> q = new SpscExactAtomicArrayQueue<Integer>(i);
-            
+
             for (int j = 0; j < i; j++) {
                 assertTrue(q.offer(j));
             }
-            
+
             assertFalse(q.offer(i));
-            
+
             for (int j = 0; j < i; j++) {
                 assertEquals((Integer)j, q.peek());
                 assertEquals((Integer)j, q.poll());
             }
-            
+
             for (int j = 0; j < RxRingBuffer.SIZE * 4; j++) {
                 assertTrue(q.offer(j));
                 assertEquals((Integer)j, q.peek());
@@ -485,46 +485,46 @@ public void testSpscExactAtomicArrayQueue() {
             }
         }
     }
-    
+
     @Test
     public void testUnboundedAtomicArrayQueue() {
         for (int i = 1; i <= RxRingBuffer.SIZE * 2; i *= 2) {
             SpscUnboundedAtomicArrayQueue<Integer> q = new SpscUnboundedAtomicArrayQueue<Integer>(i);
-            
+
             for (int j = 0; j < i; j++) {
                 assertTrue(q.offer(j));
             }
-            
+
             assertTrue(q.offer(i));
-            
+
             for (int j = 0; j < i; j++) {
                 assertEquals((Integer)j, q.peek());
                 assertEquals((Integer)j, q.poll());
             }
-            
+
             assertEquals((Integer)i, q.peek());
             assertEquals((Integer)i, q.poll());
-            
+
             for (int j = 0; j < RxRingBuffer.SIZE * 4; j++) {
                 assertTrue(q.offer(j));
                 assertEquals((Integer)j, q.peek());
                 assertEquals((Integer)j, q.poll());
             }
         }
-        
+
     }
 
-    
+
     @Test(expected = NullPointerException.class)
     public void testSpscAtomicArrayQueueNull() {
         SpscAtomicArrayQueue<Integer> q = new SpscAtomicArrayQueue<Integer>(16);
         q.offer(null);
     }
-    
+
     @Test
     public void testSpscAtomicArrayQueueOfferPoll() {
         Queue<Integer> q = new SpscAtomicArrayQueue<Integer>(128);
-        
+
         testOfferPoll(q);
     }
     @Test(expected = UnsupportedOperationException.class)
@@ -538,11 +538,11 @@ public void testSpscExactAtomicArrayQueueNull() {
         SpscExactAtomicArrayQueue<Integer> q = new SpscExactAtomicArrayQueue<Integer>(10);
         q.offer(null);
     }
-    
+
     @Test
     public void testSpscExactAtomicArrayQueueOfferPoll() {
         Queue<Integer> q = new SpscAtomicArrayQueue<Integer>(120);
-        
+
         testOfferPoll(q);
     }
     @Test(expected = UnsupportedOperationException.class)
@@ -556,11 +556,11 @@ public void testSpscUnboundedAtomicArrayQueueNull() {
         SpscUnboundedAtomicArrayQueue<Integer> q = new SpscUnboundedAtomicArrayQueue<Integer>(16);
         q.offer(null);
     }
-    
+
     @Test
     public void testSpscUnboundedAtomicArrayQueueOfferPoll() {
         Queue<Integer> q = new SpscUnboundedAtomicArrayQueue<Integer>(128);
-        
+
         testOfferPoll(q);
     }
     @Test(expected = UnsupportedOperationException.class)
diff --git a/src/test/java/rx/internal/util/LinkedArrayListTest.java b/src/test/java/rx/internal/util/LinkedArrayListTest.java
index 1b7d34fa0b..6f865cf707 100644
--- a/src/test/java/rx/internal/util/LinkedArrayListTest.java
+++ b/src/test/java/rx/internal/util/LinkedArrayListTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -24,13 +24,13 @@ public class LinkedArrayListTest {
     @Test
     public void testAdd() {
         LinkedArrayList list = new LinkedArrayList(16);
-        
+
         List<Integer> expected = new ArrayList<Integer>(32);
         for (int i = 0; i < 32; i++) {
             list.add(i);
             expected.add(i);
         }
-        
+
         assertEquals(expected, list.toList());
         assertEquals(32, list.size());
     }
diff --git a/src/test/java/rx/internal/util/OpenHashSetTest.java b/src/test/java/rx/internal/util/OpenHashSetTest.java
index b777bdbb50..9de6d0909b 100644
--- a/src/test/java/rx/internal/util/OpenHashSetTest.java
+++ b/src/test/java/rx/internal/util/OpenHashSetTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -23,20 +23,20 @@ public class OpenHashSetTest {
     @Test
     public void addRemove() {
         OpenHashSet<Integer> set = new OpenHashSet<Integer>();
-        
+
         for (int i = 0; i < 1000; i++) {
             assertTrue(set.add(i));
             assertFalse(set.add(i));
             assertTrue(set.remove(i));
             assertFalse(set.remove(i));
         }
-        
+
         Object[] values = set.values();
         for (Object i : values) {
             assertNull(i);
         }
     }
-    
+
     @Test
     public void addAllRemoveAll() {
         for (int i = 16; i < 128 * 1024; i *= 2) {
diff --git a/src/test/java/rx/internal/util/RxRingBufferBase.java b/src/test/java/rx/internal/util/RxRingBufferBase.java
index 01a7b35ca5..c13dadb9af 100644
--- a/src/test/java/rx/internal/util/RxRingBufferBase.java
+++ b/src/test/java/rx/internal/util/RxRingBufferBase.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/util/RxRingBufferSpmcTest.java b/src/test/java/rx/internal/util/RxRingBufferSpmcTest.java
index 6129022c54..d9d2f34373 100644
--- a/src/test/java/rx/internal/util/RxRingBufferSpmcTest.java
+++ b/src/test/java/rx/internal/util/RxRingBufferSpmcTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -57,7 +57,7 @@ public void testConcurrency() throws InterruptedException {
         final Producer p = new Producer() {
 
             // AtomicInteger c = new AtomicInteger();
-            
+
             @Override
             public void request(final long n) {
                 //                System.out.println("request[" + c.incrementAndGet() + "]: " + n + "  Thread: " + Thread.currentThread());
diff --git a/src/test/java/rx/internal/util/RxRingBufferSpscTest.java b/src/test/java/rx/internal/util/RxRingBufferSpscTest.java
index b1d1962eb0..4e12b1987f 100644
--- a/src/test/java/rx/internal/util/RxRingBufferSpscTest.java
+++ b/src/test/java/rx/internal/util/RxRingBufferSpscTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/internal/util/RxRingBufferWithoutUnsafeTest.java b/src/test/java/rx/internal/util/RxRingBufferWithoutUnsafeTest.java
index c7d5931887..691de7c295 100644
--- a/src/test/java/rx/internal/util/RxRingBufferWithoutUnsafeTest.java
+++ b/src/test/java/rx/internal/util/RxRingBufferWithoutUnsafeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -42,7 +42,7 @@ public void testConcurrencyLoop() throws InterruptedException {
             testConcurrency();
         }
     }
-    
+
     /**
      * Single producer, 2 consumers. The request() ensures it gets scheduled back on the same Producer thread.
      * @throws InterruptedException if the wait is interrupted
diff --git a/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java b/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java
index 6c2386812b..ef0acf2fe2 100644
--- a/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java
+++ b/src/test/java/rx/internal/util/ScalarSynchronousObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -234,15 +234,15 @@ public void onNext(Integer t) {
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
     }
-    
+
     @SuppressWarnings("rawtypes")
     @Test
     public void hookCalled() {
         Func1<OnSubscribe, OnSubscribe> save = RxJavaHooks.getOnObservableCreate();
         try {
             final AtomicInteger c = new AtomicInteger();
-            
-            
+
+
             RxJavaHooks.setOnObservableCreate(new Func1<OnSubscribe, OnSubscribe>() {
                 @Override
                 public OnSubscribe call(OnSubscribe t) {
@@ -250,13 +250,13 @@ public OnSubscribe call(OnSubscribe t) {
                     return t;
                 }
             });
-            
+
             int n = 10;
-            
+
             for (int i = 0; i < n; i++) {
                 Observable.just(1).subscribe();
             }
-            
+
             Assert.assertEquals(n, c.get());
         } finally {
             RxJavaHooks.setOnObservableCreate(save);
@@ -285,15 +285,15 @@ public void call(Subscriber<? super Object> t) {
                     return f;
                 }
             });
-            
+
             TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-            
+
             Observable.just(1).subscribe(ts);
-            
+
             ts.assertValues(1, 1);
             ts.assertNoErrors();
             ts.assertCompleted();
-            
+
         } finally {
             RxJavaHooks.setOnObservableCreate(save);
         }
diff --git a/src/test/java/rx/internal/util/SubscriptionListTest.java b/src/test/java/rx/internal/util/SubscriptionListTest.java
index 79475e60f4..43b45c8da3 100644
--- a/src/test/java/rx/internal/util/SubscriptionListTest.java
+++ b/src/test/java/rx/internal/util/SubscriptionListTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -283,14 +283,14 @@ public void run() {
         // we should have only unsubscribed once
         assertEquals(1, counter.get());
     }
-    
+
     @Test
     public void removeWhenEmpty() {
         SubscriptionList slist = new SubscriptionList();
         Subscription s = Subscriptions.empty();
-        
+
         slist.remove(s);
-        
+
         Assert.assertFalse(s.isUnsubscribed());
     }
 
@@ -299,17 +299,17 @@ public void removeNotIn() {
         SubscriptionList slist = new SubscriptionList();
         Subscription s0 = Subscriptions.empty();
         slist.add(s0);
-        
+
         Assert.assertTrue(slist.hasSubscriptions());
-        
+
         Subscription s = Subscriptions.empty();
-        
+
         slist.remove(s);
-        
+
         Assert.assertFalse(s.isUnsubscribed());
-        
+
         slist.clear();
-        
+
         Assert.assertTrue(s0.isUnsubscribed());
 
         Assert.assertFalse(slist.hasSubscriptions());
@@ -318,14 +318,14 @@ public void removeNotIn() {
     @Test
     public void unsubscribeClear() {
         SubscriptionList slist = new SubscriptionList();
-        
+
         Assert.assertFalse(slist.hasSubscriptions());
-        
+
         Subscription s0 = Subscriptions.empty();
         slist.add(s0);
-        
+
         slist.unsubscribe();
-        
+
         Assert.assertTrue(s0.isUnsubscribed());
 
         Assert.assertFalse(slist.hasSubscriptions());
diff --git a/src/test/java/rx/internal/util/SynchronizedQueueTest.java b/src/test/java/rx/internal/util/SynchronizedQueueTest.java
index 82c67d3285..977c458d7c 100644
--- a/src/test/java/rx/internal/util/SynchronizedQueueTest.java
+++ b/src/test/java/rx/internal/util/SynchronizedQueueTest.java
@@ -24,10 +24,10 @@
 
 public class SynchronizedQueueTest {
     SynchronizedQueue<Object> q = new SynchronizedQueue<Object>();
-    
+
     @Test
     public void testEquals() {
-         
+
          assertTrue(q.equals(q));
     }
 
@@ -35,17 +35,17 @@ public void testEquals() {
     public void contains() {
         q.offer(1);
         Assert.assertTrue(q.add(2));
-        
+
         Assert.assertEquals(2, q.size());
         Assert.assertTrue(q.contains(1));
         Assert.assertTrue(q.contains(2));
         Assert.assertFalse(q.contains(3));
     }
-    
+
     @Test
     public void iterator() {
         q.offer(1);
-        
+
         Assert.assertEquals(1, q.iterator().next());
     }
 
@@ -54,23 +54,23 @@ public void remove() {
         q.offer(1);
         q.offer(2);
         q.offer(3);
-        
+
         Assert.assertTrue(q.remove(2));
         Assert.assertFalse(q.remove(2));
     }
-    
+
     @Test
     public void addAllContainsAll() {
         q.addAll(Arrays.asList(1, 2, 3, 4));
-        
+
         q.removeAll(Arrays.asList(2, 3));
-        
+
         Assert.assertEquals(2, q.size());
         Assert.assertTrue(q.contains(1));
         Assert.assertFalse(q.contains(2));
         Assert.assertFalse(q.contains(3));
         Assert.assertTrue(q.contains(4));
-        
+
         Assert.assertTrue(q.containsAll(Arrays.asList(1, 4)));
         Assert.assertFalse(q.containsAll(Arrays.asList(2, 3)));
     }
@@ -78,9 +78,9 @@ public void addAllContainsAll() {
     @Test
     public void retainAll() {
         q.addAll(Arrays.asList(1, 2, 3, 4));
-        
+
         q.retainAll(Arrays.asList(2, 3));
-        
+
         Assert.assertEquals(2, q.size());
         Assert.assertFalse(q.contains(1));
         Assert.assertTrue(q.contains(2));
@@ -91,9 +91,9 @@ public void retainAll() {
     @Test
     public void clear() {
         q.addAll(Arrays.asList(1, 2, 3, 4));
-        
+
         q.clear();
-        
+
         Assert.assertEquals(0, q.size());
         Assert.assertTrue(q.isEmpty());
     }
@@ -101,14 +101,14 @@ public void clear() {
     @Test
     public void toStringValue() {
         q.offer(1);
-        
+
         Assert.assertEquals("[1]", q.toString());
     }
-    
+
     @Test
     public void equalsTo() {
         q.offer(1);
-        
+
         SynchronizedQueue<Integer> q2 = new SynchronizedQueue<Integer>();
         q2.offer(1);
 
@@ -118,30 +118,30 @@ public void equalsTo() {
         Assert.assertEquals(q, q2);
         Assert.assertEquals(q.hashCode(), q2.hashCode());
         Assert.assertNotEquals(q, q3);
-        
+
         Assert.assertFalse(q.equals(null));
         Assert.assertFalse(q.equals(1));
 
         Assert.assertEquals(q, q.clone());
 
     }
-    
+
     @Test
     public void toArray() {
         q.offer(1);
-        
+
         Object[] a = q.toArray();
-        
+
         Object[] b = q.toArray(new Integer[1]);
-        
+
         Assert.assertEquals(1, a[0]);
         Assert.assertEquals(1, b[0]);
     }
-    
+
     @Test
     public void peekElement() {
         q.offer(1);
-        
+
         Assert.assertEquals(1, q.peek());
         Assert.assertEquals(1, q.element());
         Assert.assertEquals(1, q.remove());
diff --git a/src/test/java/rx/internal/util/UtilityFunctionsTest.java b/src/test/java/rx/internal/util/UtilityFunctionsTest.java
index b8342652e2..a47b71ffaa 100644
--- a/src/test/java/rx/internal/util/UtilityFunctionsTest.java
+++ b/src/test/java/rx/internal/util/UtilityFunctionsTest.java
@@ -25,7 +25,7 @@ public class UtilityFunctionsTest {
     public void constructorShouldBePrivate() {
         TestUtil.checkUtilityClass(UtilityFunctions.class);
     }
-    
+
     @Test
     public void alwaysFalse() {
         assertEquals(1, UtilityFunctions.AlwaysFalse.values().length);
diff --git a/src/test/java/rx/observables/AsyncOnSubscribeTest.java b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
index a707757e2d..931b7c1d3f 100644
--- a/src/test/java/rx/observables/AsyncOnSubscribeTest.java
+++ b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
@@ -51,12 +51,12 @@ public class AsyncOnSubscribeTest {
     public Observer<Integer> o;
 
     TestSubscriber<Integer> subscriber;
-    
+
     @Before
     public void setup() {
         subscriber = new TestSubscriber<Integer>(o, 0L);
     }
-    
+
     @Test
     public void testSerializesConcurrentObservables() throws InterruptedException {
         final TestScheduler scheduler = new TestScheduler();
@@ -64,7 +64,7 @@ public void testSerializesConcurrentObservables() throws InterruptedException {
             @Override
             public Integer call() {
                 return 1;
-            }}, 
+            }},
         new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
@@ -77,7 +77,7 @@ else if (state == 2) {
                     Observable<Integer> o = Observable.just(5, 6, 7, 8);
                     observer.onNext(o);
                 }
-                else 
+                else
                     observer.onCompleted();
                 return state + 1;
             }});
@@ -90,17 +90,17 @@ else if (state == 2) {
         subscriber.assertNoErrors();
         subscriber.assertValues(1, 2);
         // final request completes
-        subscriber.requestMore(3); 
+        subscriber.requestMore(3);
         subscriber.assertNoErrors();
         subscriber.assertValues(1, 2, 3, 4, 5);
-        
+
         subscriber.requestMore(3);
-        
+
         subscriber.assertNoErrors();
         subscriber.assertValues(1, 2, 3, 4, 5, 6, 7, 8);
         subscriber.assertCompleted();
     }
-    
+
     @Test
     public void testSubscribedByBufferingOperator() {
         final TestScheduler scheduler = new TestScheduler();
@@ -117,7 +117,7 @@ public void call(Long requested, Observer<Observable<? extends Integer>> observe
         subscriber.assertValueCount(RxRingBuffer.SIZE);
         subscriber.assertNotCompleted();
     }
-    
+
     @Test
     public void testOnUnsubscribeHasCorrectState() throws InterruptedException {
         final AtomicInteger lastState = new AtomicInteger(-1);
@@ -125,23 +125,23 @@ public void testOnUnsubscribeHasCorrectState() throws InterruptedException {
             @Override
             public Integer call() {
                 return 1;
-            }}, 
+            }},
         new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                 if (state < 3) {
                     observer.onNext(Observable.just(state));
                 }
-                else 
+                else
                     observer.onCompleted();
                 return state + 1;
-            }}, 
+            }},
         new Action1<Integer>() {
             @Override
             public void call(Integer t) {
                 lastState.set(t);
             }});
-        Observable.create(os).subscribe(subscriber); 
+        Observable.create(os).subscribe(subscriber);
         subscriber.requestMore(1); // [[1]], state = 1
         subscriber.requestMore(2); // [[1]], state = 2
         subscriber.requestMore(3); // onComplete, state = 3
@@ -202,7 +202,7 @@ public void testThrowExceptionAfterTerminal() throws InterruptedException {
             @Override
             public Integer call() {
                 return 1;
-            }}, 
+            }},
         new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
@@ -222,7 +222,7 @@ public void testOnNextAfterCompleted() throws InterruptedException {
             @Override
             public Integer call() {
                 return 1;
-            }}, 
+            }},
         new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
@@ -243,7 +243,7 @@ public void testOnNextAfterError() throws InterruptedException {
             @Override
             public Integer call() {
                 return 1;
-            }}, 
+            }},
         new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
@@ -264,7 +264,7 @@ public void testEmittingEmptyObservable() throws InterruptedException {
             @Override
             public Integer call() {
                 return 1;
-            }}, 
+            }},
         new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
@@ -285,7 +285,7 @@ public void testOnErrorOuter() throws InterruptedException {
             @Override
             public Integer call() {
                 return 1;
-            }}, 
+            }},
         new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
@@ -299,14 +299,14 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
         subscriber.assertNotCompleted();
         subscriber.assertNoValues();
     }
-    
+
     @Test
     public void testOnCompleteFollowedByOnErrorOuter() throws InterruptedException {
         OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
             @Override
             public Integer call() {
                 return 1;
-            }}, 
+            }},
         new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
@@ -330,7 +330,7 @@ public void testUnsubscribesFromAllSelfTerminatedObservables() throws Interrupte
             @Override
             public Integer call() {
                 return 1;
-            }}, 
+            }},
         new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
@@ -359,7 +359,7 @@ public void call() {
                 observer.onNext(o1);
                 return state + 1;
             }});
-        Observable.create(os).subscribe(subscriber); 
+        Observable.create(os).subscribe(subscriber);
         subscriber.requestMore(1); // [[1]]
         subscriber.requestMore(2); // [[2]]
         subscriber.requestMore(2); // onCompleted
@@ -373,7 +373,7 @@ public void call() {
         subscriber.assertNoErrors();
         subscriber.assertCompleted();
     }
-    
+
     @Test
     public void testUnsubscribesFromAllNonTerminatedObservables() throws InterruptedException {
         final AtomicInteger l1 = new AtomicInteger();
@@ -384,7 +384,7 @@ public void testUnsubscribesFromAllNonTerminatedObservables() throws Interrupted
                 @Override
                 public Integer call() {
                     return 1;
-                }}, 
+                }},
             new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
                 @Override
                 public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
@@ -428,10 +428,10 @@ public void call() {
         assertEquals("did not unsub from 1st observable after terminal", 1, l1.get());
         assertEquals("did not unsub from Observable.never() inner obs", 1, l2.get());
     }
-    
+
     private static class Foo {}
     private static class Bar extends Foo {}
-    
+
     @Test
     public void testGenerics() {
         AsyncOnSubscribe.createStateless(new Action2<Long, Observer<Observable<? extends Foo>>>(){
@@ -443,14 +443,14 @@ public void call(Long state, Observer<Observable<? extends Foo>> observer) {
                     observer.onNext(Observable.just(new Bar()));
             }});
     }
-    
+
     @Test
     public void testUnderdeliveryCorrection() {
         OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
             @Override
             public Integer call() {
                 return 1;
-            }}, 
+            }},
         new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
@@ -465,21 +465,21 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
                 return state + 1;
             }});
         Observable.create(os).subscribe(subscriber);
-        
+
         subscriber.assertNoErrors();
         subscriber.assertNotCompleted();
         subscriber.assertNoValues();
-        
+
         subscriber.requestMore(2);
-        
+
         subscriber.assertNoErrors();
         subscriber.assertValueCount(2);
-        
+
         subscriber.requestMore(5);
 
         subscriber.assertNoErrors();
         subscriber.assertValueCount(7);
-        
+
         subscriber.assertNotCompleted();
     }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/observables/BlockingObservableTest.java b/src/test/java/rx/observables/BlockingObservableTest.java
index c20eabd01d..43e0889318 100644
--- a/src/test/java/rx/observables/BlockingObservableTest.java
+++ b/src/test/java/rx/observables/BlockingObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -636,12 +636,12 @@ private InterruptedException getInterruptedExceptionOrNull() {
     public void testRun() {
         Observable.just(1).observeOn(Schedulers.computation()).toBlocking().subscribe();
     }
-    
+
     @Test(expected = TestException.class)
     public void testRunException() {
         Observable.error(new TestException()).observeOn(Schedulers.computation()).toBlocking().subscribe();
     }
-    
+
     @Test
     public void testRunIOException() {
         try {
@@ -654,7 +654,7 @@ public void testRunIOException() {
             fail("Bad exception type: " + ex + ", " + ex.getCause());
         }
     }
-    
+
     @Test
     public void testSubscriberBackpressure() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
@@ -662,26 +662,26 @@ public void testSubscriberBackpressure() {
             public void onStart() {
                 request(2);
             }
-            
+
             @Override
             public void onNext(Integer t) {
                 super.onNext(t);
                 unsubscribe();
             }
         };
-        
+
         Observable.range(1, 10).observeOn(Schedulers.computation()).toBlocking().subscribe(ts);
-        
+
         ts.assertNoErrors();
         ts.assertNotCompleted();
         ts.assertValue(1);
     }
-    
+
     @Test(expected = OnErrorNotImplementedException.class)
     public void testOnErrorNotImplemented() {
         Observable.error(new TestException()).observeOn(Schedulers.computation()).toBlocking().subscribe(Actions.empty());
     }
-    
+
     @Test
     public void testSubscribeCallback1() {
         final boolean[] valueReceived = { false };
@@ -692,10 +692,10 @@ public void call(Integer t) {
                 assertEquals((Integer)1, t);
             }
         });
-        
+
         assertTrue(valueReceived[0]);
     }
-    
+
     @Test
     public void testSubscribeCallback2() {
         final boolean[] received = { false };
@@ -712,10 +712,10 @@ public void call(Throwable t) {
                 assertEquals(TestException.class, t.getClass());
             }
         });
-        
+
         assertTrue(received[0]);
     }
-    
+
     @Test
     public void testSubscribeCallback3() {
         final boolean[] received = { false, false };
@@ -737,7 +737,7 @@ public void call() {
                 received[1] = true;
             }
         });
-        
+
         assertTrue(received[0]);
         assertTrue(received[1]);
     }
@@ -760,7 +760,7 @@ public void call() {
                 ts.onCompleted();
             }
         });
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(TestException.class);
diff --git a/src/test/java/rx/observables/ConnectableObservableTest.java b/src/test/java/rx/observables/ConnectableObservableTest.java
index 419c694bb0..ab260e097c 100644
--- a/src/test/java/rx/observables/ConnectableObservableTest.java
+++ b/src/test/java/rx/observables/ConnectableObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -27,25 +27,25 @@ public class ConnectableObservableTest {
     @Test
     public void testAutoConnect() {
         final AtomicInteger run = new AtomicInteger();
-        
+
         ConnectableObservable<Integer> co = Observable.defer(new Func0<Observable<Integer>>() {
             @Override
             public Observable<Integer> call() {
                 return Observable.just(run.incrementAndGet());
             }
         }).publish();
-        
+
         Observable<Integer> source = co.autoConnect();
-        
+
         Assert.assertEquals(0, run.get());
-        
+
         TestSubscriber<Integer> ts1 = TestSubscriber.create();
         source.subscribe(ts1);
-        
+
         ts1.assertCompleted();
         ts1.assertNoErrors();
         ts1.assertValue(1);
-        
+
         Assert.assertEquals(1, run.get());
 
         TestSubscriber<Integer> ts2 = TestSubscriber.create();
@@ -54,31 +54,31 @@ public Observable<Integer> call() {
         ts2.assertNotCompleted();
         ts2.assertNoErrors();
         ts2.assertNoValues();
-        
+
         Assert.assertEquals(1, run.get());
     }
     @Test
     public void testAutoConnect0() {
         final AtomicInteger run = new AtomicInteger();
-        
+
         ConnectableObservable<Integer> co = Observable.defer(new Func0<Observable<Integer>>() {
             @Override
             public Observable<Integer> call() {
                 return Observable.just(run.incrementAndGet());
             }
         }).publish();
-        
+
         Observable<Integer> source = co.autoConnect(0);
-        
+
         Assert.assertEquals(1, run.get());
-        
+
         TestSubscriber<Integer> ts1 = TestSubscriber.create();
         source.subscribe(ts1);
-        
+
         ts1.assertNotCompleted();
         ts1.assertNoErrors();
         ts1.assertNoValues();
-        
+
         Assert.assertEquals(1, run.get());
 
         TestSubscriber<Integer> ts2 = TestSubscriber.create();
@@ -87,31 +87,31 @@ public Observable<Integer> call() {
         ts2.assertNotCompleted();
         ts2.assertNoErrors();
         ts2.assertNoValues();
-        
+
         Assert.assertEquals(1, run.get());
     }
     @Test
     public void testAutoConnect2() {
         final AtomicInteger run = new AtomicInteger();
-        
+
         ConnectableObservable<Integer> co = Observable.defer(new Func0<Observable<Integer>>() {
             @Override
             public Observable<Integer> call() {
                 return Observable.just(run.incrementAndGet());
             }
         }).publish();
-        
+
         Observable<Integer> source = co.autoConnect(2);
-        
+
         Assert.assertEquals(0, run.get());
-        
+
         TestSubscriber<Integer> ts1 = TestSubscriber.create();
         source.subscribe(ts1);
-        
+
         ts1.assertNotCompleted();
         ts1.assertNoErrors();
         ts1.assertNoValues();
-        
+
         Assert.assertEquals(0, run.get());
 
         TestSubscriber<Integer> ts2 = TestSubscriber.create();
@@ -126,31 +126,31 @@ public Observable<Integer> call() {
         ts2.assertCompleted();
         ts2.assertNoErrors();
         ts2.assertValue(1);
-        
+
     }
-    
+
     @Test
     public void testAutoConnectUnsubscribe() {
         final AtomicInteger run = new AtomicInteger();
-        
+
         ConnectableObservable<Integer> co = Observable.defer(new Func0<Observable<Integer>>() {
             @Override
             public Observable<Integer> call() {
                 return Observable.range(run.incrementAndGet(), 10);
             }
         }).publish();
-        
+
         final AtomicReference<Subscription> conn = new AtomicReference<Subscription>();
-        
+
         Observable<Integer> source = co.autoConnect(1, new Action1<Subscription>() {
             @Override
             public void call(Subscription t) {
                 conn.set(t);
             }
         });
-        
+
         Assert.assertEquals(0, run.get());
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
@@ -163,13 +163,13 @@ public void onNext(Integer t) {
                 }
             }
         };
-        
+
         source.subscribe(ts);
-        
+
         ts.assertNotCompleted();
         ts.assertNoErrors();
         ts.assertValue(1);
-        
+
         Assert.assertTrue("Connection not unsubscribed?", conn.get().isUnsubscribed());
     }
 }
diff --git a/src/test/java/rx/observables/SyncOnSubscribeTest.java b/src/test/java/rx/observables/SyncOnSubscribeTest.java
index 71fc0ac8e9..398c1a4d45 100644
--- a/src/test/java/rx/observables/SyncOnSubscribeTest.java
+++ b/src/test/java/rx/observables/SyncOnSubscribeTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -40,7 +40,7 @@
  * Test if SyncOnSubscribe adheres to the usual unsubscription and backpressure contracts.
  */
 public class SyncOnSubscribeTest {
-    
+
     @Test
     public void testObservableJustEquivalent() {
         OnSubscribe<Integer> os = SyncOnSubscribe.createStateless(new Action1<Observer<? super Integer>>() {
@@ -49,7 +49,7 @@ public void call(Observer<? super Integer> subscriber) {
                 subscriber.onNext(1);
                 subscriber.onCompleted();
             }});
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
 
         Observable.create(os).subscribe(ts);
@@ -66,20 +66,20 @@ public void testStateAfterTerminal() {
             @Override
             public Integer call() {
                 return 1;
-            }}, 
+            }},
             new Func2<Integer, Observer<? super Integer>, Integer>() {
                 @Override
                 public Integer call(Integer state, Observer<? super Integer> subscriber) {
                     subscriber.onNext(state);
                     subscriber.onCompleted();
                     return state + 1;
-                }}, 
+                }},
             new Action1<Integer>() {
                 @Override
                 public void call(Integer t) {
                     finalStateValue.set(t);
                 }});
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
 
         Observable.create(os).subscribe(ts);
@@ -99,7 +99,7 @@ public void call(Observer<? super Integer> subscriber) {
                 subscriber.onNext(2);
                 subscriber.onCompleted();
             }});
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
@@ -120,7 +120,7 @@ public void call(Observer<? super Integer> subscriber) {
                 subscriber.onCompleted();
                 subscriber.onCompleted();
             }});
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
@@ -140,7 +140,7 @@ public void call(Observer<? super Integer> subscriber) {
                 subscriber.onCompleted();
                 subscriber.onNext(1);
             }});
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
@@ -167,7 +167,7 @@ public void call(Observer<? super Integer> subscriber) {
                 subscriber.onError(new TestException("Forced failure 1"));
                 subscriber.onError(new FooException("Should not see this error."));
             }});
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
@@ -202,7 +202,7 @@ public void testNever() {
         OnSubscribe<Integer> os = SyncOnSubscribe.createStateless(new Action1<Observer<? super Integer>>() {
             @Override
             public void call(Observer<? super Integer> subscriber) {
-                
+
             }});
 
 
@@ -303,7 +303,7 @@ public void testRange() {
             @Override
             public Integer call() {
                 return start;
-            }}, 
+            }},
             new Func2<Integer, Observer<? super Integer>, Integer>() {
                 @Override
                 public Integer call(Integer state, Observer<? super Integer> subscriber) {
@@ -339,7 +339,7 @@ public void testFromIterable() {
                 @Override
                 public Iterator<Integer> call() {
                     return source.iterator();
-                }}, 
+                }},
             new Func2<Iterator<Integer>, Observer<? super Integer>, Iterator<Integer>>() {
                 @Override
                 public Iterator<Integer> call(Iterator<Integer> it, Observer<? super Integer> observer) {
@@ -374,7 +374,7 @@ public void testInfiniteTake() {
                     @Override
                     public Integer call() {
                         return start;
-                    }}, 
+                    }},
                 new Func2<Integer, Observer<? super Integer>, Integer>() {
                     @Override
                     public Integer call(Integer state, Observer<? super Integer> observer) {
@@ -397,16 +397,16 @@ public Integer call(Integer state, Observer<? super Integer> observer) {
     public void testInfiniteRequestSome() {
         final int finalCount = 4000;
         final int start = 0;
-        
+
         @SuppressWarnings("unchecked")
         Action1<? super Integer> onUnSubscribe = mock(Action1.class);
-        
+
         OnSubscribe<Integer> os = SyncOnSubscribe.createStateful(
                 new Func0<Integer>() {
                     @Override
                     public Integer call() {
                         return start;
-                    }}, 
+                    }},
                 new Func2<Integer, Observer<? super Integer>, Integer>() {
                     @Override
                     public Integer call(Integer state, Observer<? super Integer> observer) {
@@ -431,13 +431,13 @@ public Integer call(Integer state, Observer<? super Integer> observer) {
     public void testUnsubscribeDownstream() {
         @SuppressWarnings("unchecked")
         Action1<? super Integer> onUnSubscribe = mock(Action1.class);
-        
+
         OnSubscribe<Integer> os = SyncOnSubscribe.createStateful(
                 new Func0<Integer>() {
                     @Override
                     public Integer call() {
                         return null;
-                    }}, 
+                    }},
                 new Func2<Integer, Observer<? super Integer>, Integer>() {
                     @Override
                     public Integer call(Integer state, Observer<? super Integer> observer) {
@@ -466,7 +466,7 @@ public void testConcurrentRequestsLoop() throws InterruptedException {
             testConcurrentRequests();
         }
     }
-    
+
     @Test
     public void testConcurrentRequests() throws InterruptedException {
         final int count1 = 1000;
@@ -475,7 +475,7 @@ public void testConcurrentRequests() throws InterruptedException {
         final int start = 1;
         final CountDownLatch l1 = new CountDownLatch(1);
         final CountDownLatch l2 = new CountDownLatch(1);
-        
+
         final CountDownLatch l3 = new CountDownLatch(1);
 
         final Action1<Object> onUnSubscribe = new Action1<Object>() {
@@ -484,13 +484,13 @@ public void call(Object t) {
                 l3.countDown();
             }
         };
-        
+
         OnSubscribe<Integer> os = SyncOnSubscribe.createStateful(
                 new Func0<Integer>() {
                     @Override
                     public Integer call() {
                         return start;
-                    }}, 
+                    }},
                 new Func2<Integer, Observer<? super Integer>, Integer>() {
                     @Override
                     public Integer call(Integer state, Observer<? super Integer> observer) {
@@ -507,11 +507,11 @@ public Integer call(Integer state, Observer<? super Integer> observer) {
                             return state + 1;
                         }
                         observer.onNext(state);
-                        
+
                         if (state == finalCount) {
                             observer.onCompleted();
                         }
-                        
+
                         return state + 1;
                     }},
                 onUnSubscribe);
@@ -538,7 +538,7 @@ public Integer call(Integer state, Observer<? super Integer> observer) {
         inOrder.verify(o, times(finalCount)).onNext(any());
         inOrder.verify(o, times(1)).onCompleted();
         inOrder.verifyNoMoreInteractions();
-        
+
         if (!l3.await(2, TimeUnit.SECONDS)) {
             fail("SyncOnSubscribe failed to countDown onUnSubscribe latch");
         }
@@ -548,7 +548,7 @@ public Integer call(Integer state, Observer<? super Integer> observer) {
     public void testUnsubscribeOutsideOfLoop() throws InterruptedException {
         final AtomicInteger calledUnsubscribe = new AtomicInteger(0);
         final AtomicBoolean currentlyEvaluating = new AtomicBoolean(false);
-        
+
         OnSubscribe<Void> os = SyncOnSubscribe.createStateless(
                 new Action1<Observer<? super Void>>() {
                     @Override
@@ -561,7 +561,7 @@ public void call(Observer<? super Void> observer) {
                     @Override
                     public void call() {
                         calledUnsubscribe.incrementAndGet();
-                        assertFalse(currentlyEvaluating.get());                        
+                        assertFalse(currentlyEvaluating.get());
                     }});
 
         @SuppressWarnings("unchecked")
@@ -610,21 +610,21 @@ public void run() {
         ts.assertUnsubscribed();
         assertEquals(1, calledUnsubscribe.get());
     }
-    
+
     @Test
     public void testIndependentStates() {
         int count = 100;
         final ConcurrentHashMap<Object, Object> subscribers = new ConcurrentHashMap<Object, Object>();
-        
+
         @SuppressWarnings("unchecked")
         Action1<? super Map<Object, Object>> onUnSubscribe = mock(Action1.class);
-        
+
         OnSubscribe<Integer> os = SyncOnSubscribe.createStateful(
             new Func0<Map<Object, Object>>() {
                 @Override
                 public Map<Object, Object> call() {
                     return subscribers;
-                }}, 
+                }},
             new Func2<Map<Object, Object>, Observer<? super Integer>, Map<Object, Object>>() {
                 @Override
                 public Map<Object, Object> call(Map<Object, Object> state, Observer<? super Integer> observer) {
@@ -633,7 +633,7 @@ public Map<Object, Object> call(Map<Object, Object> state, Observer<? super Inte
                     return state;
                 }},
             onUnSubscribe);
-        
+
         Observable<Integer> source = Observable.create(os);
         for (int i = 0; i < count; i++) {
             source.subscribe();
@@ -649,13 +649,13 @@ public void testSubscribeOn() {
         final int count = 400;
         final AtomicInteger countUnsubscribe = new AtomicInteger(0);
         final int numSubscribers = 4;
-        
+
         OnSubscribe<Integer> os = SyncOnSubscribe.<Integer, Integer>createStateful(
                 new Func0<Integer>() {
                     @Override
                     public Integer call() {
                         return start;
-                    }}, 
+                    }},
                 new Func2<Integer, Observer<? super Integer>, Integer>() {
                     @Override
                     public Integer call(Integer calls, Observer<? super Integer> observer) {
@@ -689,7 +689,7 @@ public void call(Integer t) {
             ts.assertValueCount(count);
             ts.assertCompleted();
         }
-        
+
         assertEquals(numSubscribers, countUnsubscribe.get());
     }
 
@@ -697,14 +697,14 @@ public void call(Integer t) {
     public void testObserveOn() {
         final int start = 1;
         final int count = 4000;
-        
+
         @SuppressWarnings("unchecked")
         Action1<? super Integer> onUnSubscribe = mock(Action1.class);
         @SuppressWarnings("unchecked")
         Func0<Integer> generator = mock(Func0.class);
         Mockito.when(generator.call()).thenReturn(start);
-        
-        OnSubscribe<Integer> os = SyncOnSubscribe.createStateful(generator, 
+
+        OnSubscribe<Integer> os = SyncOnSubscribe.createStateful(generator,
                 new Func2<Integer, Observer<? super Integer>, Integer>() {
                     @Override
                     public Integer call(Integer calls, Observer<? super Integer> observer) {
@@ -737,7 +737,7 @@ public Integer call(Integer calls, Observer<? super Integer> observer) {
     @Test
     public void testCanRequestInOnNext() {
         Action0 onUnSubscribe = mock(Action0.class);
-        
+
         OnSubscribe<Integer> os = SyncOnSubscribe.createStateless(
                 new Action1<Observer<? super Integer>>() {
                     @Override
@@ -781,7 +781,7 @@ protected Object generateState() {
                 lastState.set(o);
                 return o;
             }
-            
+
             @Override
             protected Object next(Object state, Observer<? super Object> observer) {
                 observer.onNext(lastState.get());
@@ -790,14 +790,14 @@ protected Object next(Object state, Observer<? super Object> observer) {
                 lastState.set(o);
                 return o;
             }
-            
+
             @Override
             protected void onUnsubscribe(Object state) {
                 countUnsubs.incrementAndGet();
                 assertEquals(lastState.get(), state);
             }
         };
-        
+
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
@@ -811,12 +811,12 @@ protected void onUnsubscribe(Object state) {
         verify(o).onCompleted();
         assertEquals(1, countUnsubs.get());
     }
-    
+
     private interface FooQux {}
     private static class Foo implements FooQux {}
     private interface BarQux extends FooQux {}
     private static class Bar extends Foo implements BarQux {}
-    
+
     @Test
     public void testGenericsCreateSingleState() {
         Func0<? extends BarQux> generator = new Func0<Bar>() {
@@ -849,7 +849,7 @@ public void call(BarQux state, Observer<? super FooQux> observer) {
         Action1<? super BarQux> unsub = new Action1<FooQux>() {
             @Override
             public void call(FooQux t) {
-                
+
             }};
             assertJustBehavior(SyncOnSubscribe.createSingleState(generator, next, unsub));
     }
@@ -888,12 +888,12 @@ public BarQux call(BarQux state, Observer<? super FooQux> observer) {
         Action1<? super BarQux> unsub = new Action1<FooQux>() {
             @Override
             public void call(FooQux t) {
-                
+
             }};
         OnSubscribe<FooQux> os = SyncOnSubscribe.createStateful(generator, next, unsub);
         assertJustBehavior(os);
     }
-    
+
     @Test
     public void testGenericsCreateStateless() {
         Action1<Observer<? super FooQux>> next = new Action1<Observer<? super FooQux>>() {
@@ -917,7 +917,7 @@ public void call(Observer<? super FooQux> observer) {
         Action0 unsub = new Action0() {
             @Override
             public void call() {
-                
+
             }};
         OnSubscribe<FooQux> os = SyncOnSubscribe.createStateless(next, unsub);
         assertJustBehavior(os);
@@ -930,25 +930,25 @@ private void assertJustBehavior(OnSubscribe<FooQux> os) {
         ts.assertNoErrors();
         ts.assertValueCount(1);
     }
-    
+
     @Test
     public void testConcurrentUnsubscribe3000Iterations() throws InterruptedException, BrokenBarrierException, ExecutionException{
         ExecutorService exec = null;
         try {
-            exec = Executors.newSingleThreadExecutor(); 
+            exec = Executors.newSingleThreadExecutor();
             for (int i = 0; i < 3000; i++) {
                 final AtomicInteger wip = new AtomicInteger();
-                
+
                 Func0<AtomicInteger> func0 = new Func0<AtomicInteger>() {
                     @Override
                     public AtomicInteger call() {
                         return wip;
                     }
                 };
-                Func2<AtomicInteger, Observer<? super Integer>, AtomicInteger> func2 = 
+                Func2<AtomicInteger, Observer<? super Integer>, AtomicInteger> func2 =
                         new Func2<AtomicInteger, Observer<? super Integer>, AtomicInteger>() {
                     @Override
-                    public AtomicInteger call(AtomicInteger s, Observer<? super Integer> o) { 
+                    public AtomicInteger call(AtomicInteger s, Observer<? super Integer> o) {
                         o.onNext(1);
                         return s;
                     }
@@ -960,17 +960,17 @@ public void call(AtomicInteger s) {
                     }
                 };
                 Observable<Integer> source = Observable.create(
-                        SyncOnSubscribe.createStateful( 
-                        func0, 
+                        SyncOnSubscribe.createStateful(
+                        func0,
                         func2, action1
                 ));
-            
-            
+
+
                 final TestSubscriber<Integer> ts = TestSubscriber.create(0);
                 source.subscribe(ts);
-            
+
                 final CyclicBarrier cb = new CyclicBarrier(2);
-            
+
                 Future<?> f = exec.submit(new Callable<Object>() {
                     @Override
                     public Object call() throws Exception {
@@ -979,7 +979,7 @@ public Object call() throws Exception {
                         return null;
                     }
                 });
-            
+
                 cb.await();
                 ts.unsubscribe();
                 f.get();
@@ -989,11 +989,11 @@ public Object call() throws Exception {
             if (exec != null) exec.shutdownNow();
         }
     }
-    
+
     @Test
     public void testStateThrows() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
-        
+
         SyncOnSubscribe.<Object, Object>createSingleState(
                 new Func0<Object>() {
                     @Override
@@ -1003,11 +1003,11 @@ public Object call() {
                 }
         , new Action2<Object, Observer<Object>>() {
             @Override
-            public void call(Object s, Observer<? super Object> o) { 
-                
+            public void call(Object s, Observer<? super Object> o) {
+
             }
         }).call(ts);
-        
+
         ts.assertNoValues();
         ts.assertError(TestException.class);
         ts.assertNotCompleted();
diff --git a/src/test/java/rx/observers/AsyncCompletableSubscriberTest.java b/src/test/java/rx/observers/AsyncCompletableSubscriberTest.java
index 7ac34f1628..95782b687a 100644
--- a/src/test/java/rx/observers/AsyncCompletableSubscriberTest.java
+++ b/src/test/java/rx/observers/AsyncCompletableSubscriberTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -27,37 +27,37 @@ public class AsyncCompletableSubscriberTest {
 
     static final class TestCS extends AsyncCompletableSubscriber {
         int started;
-        
+
         int completions;
-        
+
         final List<Throwable> errors = new ArrayList<Throwable>();
-        
+
         @Override
         protected void onStart() {
             started++;
         }
-        
+
         @Override
         public void onCompleted() {
             completions++;
             clear();
         }
-        
+
         @Override
         public void onError(Throwable e) {
             errors.add(e);
             clear();
         }
     }
-    
+
     @Test
     public void normal() {
         TestCS ts = new TestCS();
-        
+
         Assert.assertFalse(ts.isUnsubscribed());
-        
+
         Completable.complete().subscribe(ts);
-        
+
         Assert.assertEquals(1, ts.started);
         Assert.assertEquals(1, ts.completions);
         Assert.assertEquals(ts.errors.toString(), 0, ts.errors.size());
@@ -67,11 +67,11 @@ public void normal() {
     @Test
     public void error() {
         TestCS ts = new TestCS();
-        
+
         Assert.assertFalse(ts.isUnsubscribed());
-        
+
         Completable.error(new TestException("Forced failure")).subscribe(ts);
-        
+
         Assert.assertEquals(1, ts.started);
         Assert.assertEquals(0, ts.completions);
         Assert.assertEquals(ts.errors.toString(), 1, ts.errors.size());
@@ -80,16 +80,16 @@ public void error() {
         Assert.assertTrue(ts.isUnsubscribed());
     }
 
-    
+
     @Test
     public void unsubscribed() {
         TestCS ts = new TestCS();
         ts.unsubscribe();
-        
+
         Assert.assertTrue(ts.isUnsubscribed());
-        
+
         Observable.range(1, 10).toCompletable().subscribe(ts);
-        
+
         Assert.assertEquals(0, ts.started);
         Assert.assertEquals(0, ts.completions);
         Assert.assertEquals(ts.errors.toString(), 0, ts.errors.size());
diff --git a/src/test/java/rx/observers/CompletableSubscriberTest.java b/src/test/java/rx/observers/CompletableSubscriberTest.java
index e7281c0796..5ae2351960 100644
--- a/src/test/java/rx/observers/CompletableSubscriberTest.java
+++ b/src/test/java/rx/observers/CompletableSubscriberTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -30,161 +30,161 @@ public class CompletableSubscriberTest {
 
     @Test
     public void childOnSubscribeThrows() {
-        
+
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        
+
         SafeCompletableSubscriber safe = new SafeCompletableSubscriber(new CompletableSubscriber() {
-            
+
             @Override
             public void onSubscribe(Subscription d) {
                 throw new TestException();
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 error.set(e);
-                
+
             }
-            
+
             @Override
             public void onCompleted() {
-                
+
             }
         });
-        
+
         safe.onSubscribe(Subscriptions.empty());
-        
+
         Assert.assertTrue("" + error.get(), error.get() instanceof TestException);
-        
+
         Assert.assertTrue(safe.isUnsubscribed());
     }
-    
+
     @Test
     public void unsubscribeComposes() {
-        
+
         SafeCompletableSubscriber safe = new SafeCompletableSubscriber(new CompletableSubscriber() {
-            
+
             @Override
             public void onSubscribe(Subscription d) {
             }
-            
+
             @Override
             public void onError(Throwable e) {
             }
-            
+
             @Override
             public void onCompleted() {
-                
+
             }
         });
-        
+
         Subscription empty = Subscriptions.empty();
         safe.onSubscribe(empty);
-        
+
         Assert.assertFalse(empty.isUnsubscribed());
         Assert.assertFalse(safe.isUnsubscribed());
-        
+
         safe.unsubscribe();
-        
+
         Assert.assertTrue(empty.isUnsubscribed());
         Assert.assertTrue(safe.isUnsubscribed());
     }
-    
+
     @Test
     public void childOnErrorThrows() {
-        
+
         SafeCompletableSubscriber safe = new SafeCompletableSubscriber(new CompletableSubscriber() {
-            
+
             @Override
             public void onSubscribe(Subscription d) {
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 throw new TestException();
             }
-            
+
             @Override
             public void onCompleted() {
-                
+
             }
         });
-        
+
         safe.onSubscribe(Subscriptions.empty());
-        
+
         try {
             safe.onError(new IOException());
             Assert.fail("Didn't throw a fatal exception");
         } catch (OnErrorFailedException ex) {
             CompositeException ce = (CompositeException)ex.getCause();
-            
+
             List<Throwable> list = ce.getExceptions();
             Assert.assertEquals(2, list.size());
-            
+
             Assert.assertTrue("" + list.get(0), list.get(0) instanceof IOException);
             Assert.assertTrue("" + list.get(1), list.get(1) instanceof TestException);
         }
     }
-    
+
     @Test
     public void preventsCompleteError() {
 
         final boolean[] calls = { false, false };
-        
+
         SafeCompletableSubscriber safe = new SafeCompletableSubscriber(new CompletableSubscriber() {
-            
+
             @Override
             public void onSubscribe(Subscription d) {
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 calls[0] = true;
             }
-            
+
             @Override
             public void onCompleted() {
                 calls[1] = true;
             }
         });
-        
+
         safe.onSubscribe(Subscriptions.empty());
 
         safe.onCompleted();
         safe.onError(new TestException());
-        
+
         Assert.assertTrue(safe.isUnsubscribed());
         Assert.assertFalse(calls[0]);
         Assert.assertTrue(calls[1]);
     }
-    
+
     @Test
     public void preventsErrorComplete() {
 
         final boolean[] calls = { false, false };
-        
+
         SafeCompletableSubscriber safe = new SafeCompletableSubscriber(new CompletableSubscriber() {
-            
+
             @Override
             public void onSubscribe(Subscription d) {
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 calls[0] = true;
             }
-            
+
             @Override
             public void onCompleted() {
                 calls[1] = true;
             }
         });
-        
+
         safe.onSubscribe(Subscriptions.empty());
 
         safe.onError(new TestException());
         safe.onCompleted();
-        
+
         Assert.assertTrue(safe.isUnsubscribed());
         Assert.assertTrue(calls[0]);
         Assert.assertFalse(calls[1]);
diff --git a/src/test/java/rx/observers/ObserversTest.java b/src/test/java/rx/observers/ObserversTest.java
index f769af88d9..fb7caa4264 100644
--- a/src/test/java/rx/observers/ObserversTest.java
+++ b/src/test/java/rx/observers/ObserversTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -34,7 +34,7 @@ public class ObserversTest {
     public void constructorShouldBePrivate() {
         TestUtil.checkUtilityClass(Observers.class);
     }
-    
+
     @Test
     public void testEmptyOnErrorNotImplemented() {
         try {
@@ -70,7 +70,7 @@ public void testCreate2Null() {
     public void testCreate3Null() {
         Observers.create(Actions.empty(), null);
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void testCreate4Null() {
         Action1<Throwable> throwAction = Actions.empty();
@@ -85,7 +85,7 @@ public void testCreate6Null() {
         Action1<Throwable> throwAction = Actions.empty();
         Observers.create(Actions.empty(), throwAction, null);
     }
-    
+
     @Test
     public void testCreate1Value() {
         final AtomicInteger value = new AtomicInteger();
@@ -96,7 +96,7 @@ public void call(Integer t) {
             }
         };
         Observers.create(action).onNext(1);
-        
+
         assertEquals(1, value.get());
     }
     @Test
@@ -110,10 +110,10 @@ public void call(Integer t) {
         };
         Action1<Throwable> throwAction = Actions.empty();
         Observers.create(action, throwAction).onNext(1);
-        
+
         assertEquals(1, value.get());
     }
-    
+
     @Test
     public void testCreate3Value() {
         final AtomicInteger value = new AtomicInteger();
@@ -125,10 +125,10 @@ public void call(Integer t) {
         };
         Action1<Throwable> throwAction = Actions.empty();
         Observers.create(action, throwAction, Actions.empty()).onNext(1);
-        
+
         assertEquals(1, value.get());
     }
-    
+
     @Test
     public void testError2() {
         final AtomicReference<Throwable> value = new AtomicReference<Throwable>();
@@ -140,10 +140,10 @@ public void call(Throwable t) {
         };
         TestException exception = new TestException();
         Observers.create(Actions.empty(), action).onError(exception);
-        
+
         assertEquals(exception, value.get());
     }
-    
+
     @Test
     public void testError3() {
         final AtomicReference<Throwable> value = new AtomicReference<Throwable>();
@@ -155,28 +155,28 @@ public void call(Throwable t) {
         };
         TestException exception = new TestException();
         Observers.create(Actions.empty(), action, Actions.empty()).onError(exception);
-        
+
         assertEquals(exception, value.get());
     }
-    
+
     @Test
     public void testCompleted() {
         Action0 action = mock(Action0.class);
-        
+
         Action1<Throwable> throwAction = Actions.empty();
         Observers.create(Actions.empty(), throwAction, action).onCompleted();
 
         verify(action).call();
     }
-    
+
     @Test
     public void testEmptyCompleted() {
         Observers.create(Actions.empty()).onCompleted();
-        
+
         Action1<Throwable> throwAction = Actions.empty();
         Observers.create(Actions.empty(), throwAction).onCompleted();
     }
-    
+
     @Test
     public void onCompleteQueues() {
         @SuppressWarnings("unchecked")
@@ -188,45 +188,45 @@ public void onNext(Integer t) {
                 observer[0].onNext(1);
                 observer[0].onCompleted();
             }
-            
+
             @Override
             public void onError(Throwable e) {
-                
+
             }
-            
+
             @Override
             public void onCompleted() {
                 completeCalled[0] = true;
             }
         });
         observer[0] = so;
-        
+
         so.onNext(1);
-        
+
         Assert.assertTrue(completeCalled[0]);
     }
-    
+
     @Test
     public void concurrentOnError() throws Exception {
         final Queue<Throwable> queue = new ConcurrentLinkedQueue<Throwable>();
-        
+
         final SerializedObserver<Integer> so = new SerializedObserver<Integer>(new Observer<Integer>() {
             @Override
             public void onNext(Integer t) {
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 queue.offer(e);
             }
-            
+
             @Override
             public void onCompleted() {
             }
         });
 
         final CountDownLatch cdl = new CountDownLatch(1);
-        
+
         synchronized (so) {
             Thread t = new Thread(new Runnable() {
                 @Override
@@ -238,19 +238,19 @@ public void run() {
             t.start();
 
             Thread.sleep(200);
-            
+
             so.onError(new TestException());
         }
-        
+
         if (!cdl.await(5, TimeUnit.SECONDS)) {
             fail("The wait timed out");
         }
-        
+
         Assert.assertEquals(1, queue.size());
         Throwable ex = queue.poll();
         Assert.assertTrue("" + ex, ex instanceof TestException);
     }
-    
+
     @Test
     public void concurrentOnComplete() throws Exception {
         final int[] completed = { 0 };
@@ -258,11 +258,11 @@ public void concurrentOnComplete() throws Exception {
             @Override
             public void onNext(Integer t) {
             }
-            
+
             @Override
             public void onError(Throwable e) {
             }
-            
+
             @Override
             public void onCompleted() {
                 completed[0]++;
@@ -270,7 +270,7 @@ public void onCompleted() {
         });
 
         final CountDownLatch cdl = new CountDownLatch(1);
-        
+
         synchronized (so) {
             Thread t = new Thread(new Runnable() {
                 @Override
@@ -282,14 +282,14 @@ public void run() {
             t.start();
 
             Thread.sleep(200);
-            
+
             so.onCompleted();
         }
-        
+
         if (!cdl.await(5, TimeUnit.SECONDS)) {
             fail("The wait timed out");
         }
-        
+
         Assert.assertEquals(1, completed[0]);
     }
 }
diff --git a/src/test/java/rx/observers/SafeObserverTest.java b/src/test/java/rx/observers/SafeObserverTest.java
index 0863ff9e50..088b465d3d 100644
--- a/src/test/java/rx/observers/SafeObserverTest.java
+++ b/src/test/java/rx/observers/SafeObserverTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -444,14 +444,14 @@ public SafeObserverTestException(String message) {
             super(message);
         }
     }
-    
+
     @Test
     public void testOnCompletedThrows() {
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
         SafeSubscriber<Integer> s = new SafeSubscriber<Integer>(new Subscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
-                
+
             }
             @Override
             public void onError(Throwable e) {
@@ -462,7 +462,7 @@ public void onCompleted() {
                 throw new TestException();
             }
         });
-        
+
         try {
             s.onCompleted();
             Assert.fail();
@@ -470,7 +470,7 @@ public void onCompleted() {
            assertNull(error.get());
         }
     }
-    
+
     @Test
     public void testActual() {
         Subscriber<Integer> actual = new Subscriber<Integer>() {
@@ -485,7 +485,7 @@ public void onCompleted() {
             }
         };
         SafeSubscriber<Integer> s = new SafeSubscriber<Integer>(actual);
-        
+
         assertSame(actual, s.getActual());
     }
 }
diff --git a/src/test/java/rx/observers/SafeSubscriberTest.java b/src/test/java/rx/observers/SafeSubscriberTest.java
index 30d4ee905b..7d60a71c9f 100644
--- a/src/test/java/rx/observers/SafeSubscriberTest.java
+++ b/src/test/java/rx/observers/SafeSubscriberTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -37,7 +37,7 @@
 
 @SuppressWarnings("deprecation")
 public class SafeSubscriberTest {
-    
+
     @Before
     @After
     public void resetBefore() {
@@ -60,7 +60,7 @@ public void onCompleted() {
             assertTrue(safe.isUnsubscribed());
         }
     }
-    
+
     @Test
     public void testOnCompletedThrows2() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
@@ -70,16 +70,16 @@ public void onCompleted() {
             }
         };
         SafeSubscriber<Integer> safe = new SafeSubscriber<Integer>(ts);
-        
+
         try {
             safe.onCompleted();
         } catch (OnErrorNotImplementedException ex) {
             // expected
         }
-        
+
         assertTrue(safe.isUnsubscribed());
     }
-    
+
     @Test(expected=OnCompletedFailedException.class)
     public void testPluginException() {
         RxJavaPlugins.getInstance().registerErrorHandler(new RxJavaErrorHandler() {
@@ -88,7 +88,7 @@ public void handleError(Throwable e) {
                 throw new RuntimeException();
             }
         });
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onCompleted() {
@@ -96,10 +96,10 @@ public void onCompleted() {
             }
         };
         SafeSubscriber<Integer> safe = new SafeSubscriber<Integer>(ts);
-        
+
         safe.onCompleted();
     }
-    
+
     @Test(expected = OnErrorFailedException.class)
     public void testPluginExceptionWhileOnErrorUnsubscribeThrows() {
         RxJavaPlugins.getInstance().registerErrorHandler(new RxJavaErrorHandler() {
@@ -111,7 +111,7 @@ public void handleError(Throwable e) {
                 }
             }
         });
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         SafeSubscriber<Integer> safe = new SafeSubscriber<Integer>(ts);
         safe.add(Subscriptions.create(new Action0() {
@@ -120,10 +120,10 @@ public void call() {
                 throw new RuntimeException();
             }
         }));
-        
+
         safe.onError(new TestException());
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testPluginExceptionWhileOnErrorThrowsNotImplAndUnsubscribeThrows() {
         RxJavaPlugins.getInstance().registerErrorHandler(new RxJavaErrorHandler() {
@@ -135,7 +135,7 @@ public void handleError(Throwable e) {
                 }
             }
         });
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onError(Throwable e) {
@@ -149,10 +149,10 @@ public void call() {
                 throw new RuntimeException();
             }
         }));
-        
+
         safe.onError(new TestException());
     }
-    
+
     @Test(expected = OnErrorFailedException.class)
     public void testPluginExceptionWhileOnErrorThrows() {
         RxJavaPlugins.getInstance().registerErrorHandler(new RxJavaErrorHandler() {
@@ -164,7 +164,7 @@ public void handleError(Throwable e) {
                 }
             }
         });
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onError(Throwable e) {
@@ -172,7 +172,7 @@ public void onError(Throwable e) {
             }
         };
         SafeSubscriber<Integer> safe = new SafeSubscriber<Integer>(ts);
-        
+
         safe.onError(new TestException());
     }
     @Test(expected = OnErrorFailedException.class)
@@ -186,7 +186,7 @@ public void handleError(Throwable e) {
                 }
             }
         });
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onError(Throwable e) {
@@ -200,7 +200,7 @@ public void call() {
                 throw new RuntimeException();
             }
         }));
-        
+
         safe.onError(new TestException());
     }
     @Test(expected = OnErrorFailedException.class)
@@ -214,7 +214,7 @@ public void handleError(Throwable e) {
                 }
             }
         });
-        
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onError(Throwable e) {
@@ -228,10 +228,10 @@ public void call() {
                 throw new RuntimeException();
             }
         }));
-        
+
         safe.onError(new TestException());
     }
-    
+
     @Test
     public void testPluginErrorHandlerReceivesExceptionWhenUnsubscribeAfterCompletionThrows() {
         final AtomicInteger calls = new AtomicInteger();
@@ -241,7 +241,7 @@ public void handleError(Throwable e) {
                 calls.incrementAndGet();
             }
         });
-        
+
         final AtomicInteger errors = new AtomicInteger();
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
@@ -257,7 +257,7 @@ public void call() {
                 throw ex;
             }
         }));
-        
+
         try {
             safe.onCompleted();
             Assert.fail();
@@ -276,15 +276,15 @@ public void handleError(Throwable e) {
                 calls.incrementAndGet();
             }
         });
-        
+
         final AtomicInteger errors = new AtomicInteger();
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
-            
-            @Override 
+
+            @Override
             public void onCompleted() {
                 throw new RuntimeException();
             }
-            
+
             @Override
             public void onError(Throwable e) {
                 errors.incrementAndGet();
@@ -297,7 +297,7 @@ public void call() {
                 throw new RuntimeException();
             }
         }));
-        
+
         try {
             safe.onCompleted();
             Assert.fail();
@@ -307,5 +307,5 @@ public void call() {
         }
     }
 
-    
+
 }
diff --git a/src/test/java/rx/observers/SerializedObserverTest.java b/src/test/java/rx/observers/SerializedObserverTest.java
index 9897843e3a..41d6d2da6d 100644
--- a/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/src/test/java/rx/observers/SerializedObserverTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -126,7 +126,7 @@ public void testMultiThreadedWithNPE() throws InterruptedException {
     public void testMultiThreadedWithNPEinMiddle() {
         int n = 10;
         for (int i = 0; i < n; i++) {
-            TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null, 
+            TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null,
                     "four", "five", "six", "seven", "eight", "nine");
             Observable<String> w = Observable.create(onSubscribe);
 
@@ -254,7 +254,7 @@ public void runConcurrencyTest() {
 
     /**
      * Test that a notification does not get delayed in the queue waiting for the next event to push it through.
-     * 
+     *
      * @throws InterruptedException
      */
     @Test
@@ -263,12 +263,12 @@ public void testNotificationDelay() throws InterruptedException {
         try {
             int n = 10000;
             for (int i = 0; i < n; i++) {
-                
+
                 @SuppressWarnings("unchecked")
                 final Observer<Integer>[] os = new Observer[1];
-                
+
                 final List<Thread> threads = new ArrayList<Thread>();
-                
+
                 final Observer<Integer> o = new SerializedObserver<Integer>(new Observer<Integer>() {
                     boolean first;
                     @Override
@@ -290,25 +290,25 @@ public void run() {
                             }
                         }
                     }
-                    
+
                     @Override
-                    public void onError(Throwable e) { 
+                    public void onError(Throwable e) {
                         e.printStackTrace();
                     }
-                    
+
                     @Override
-                    public void onCompleted() { 
-                        
+                    public void onCompleted() {
+
                     }
                 });
-                
+
                 os[0] = o;
-                
+
                 o.onNext(1);
-                
+
                 System.out.println(threads);
                 assertEquals(2, threads.size());
-                
+
                 assertSame(threads.get(0), threads.get(1));
             }
         } finally {
@@ -318,22 +318,22 @@ public void onCompleted() {
 
     /**
      * Demonstrates thread starvation problem.
-     * 
+     *
      * No solution on this for now. Trade-off in this direction as per https://github.com/ReactiveX/RxJava/issues/998#issuecomment-38959474
      * Probably need backpressure for this to work
-     * 
+     *
      * When using SynchronizedObserver we get this output:
-     * 
+     *
      * p1: 18 p2: 68 => should be close to each other unless we have thread starvation
-     * 
+     *
      * When using SerializedObserver we get:
-     * 
+     *
      * p1: 1 p2: 2445261 => should be close to each other unless we have thread starvation
-     * 
+     *
      * This demonstrates how SynchronizedObserver balances back and forth better, and blocks emission.
      * The real issue in this example is the async buffer-bloat, so we need backpressure.
-     * 
-     * 
+     *
+     *
      * @throws InterruptedException
      */
     @Ignore("Demonstrates thread starvation problem. Read JavaDoc")
@@ -541,7 +541,7 @@ public void onNext(String args) {
 
         /**
          * Assert the order of events is correct and return the number of onNext executions.
-         * 
+         *
          * @param expectedEndingEvent
          * @return int count of onNext calls
          * @throws IllegalStateException
@@ -788,7 +788,7 @@ protected void captureMaxThreads() {
         }
 
     }
-    
+
     @Test
     public void testSerializeNull() {
         final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>();
@@ -801,15 +801,15 @@ public void onNext(Integer t) {
                 super.onNext(t);
             }
         };
-        
+
         SerializedObserver<Integer> sobs = new SerializedObserver<Integer>(to);
         serial.set(sobs);
-        
+
         sobs.onNext(0);
-        
+
         to.assertReceivedOnNext(Arrays.asList(0, null));
     }
-    
+
     @Test
     public void testSerializeAllowsOnError() {
         TestSubscriber<Integer> to = new TestSubscriber<Integer>() {
@@ -818,19 +818,19 @@ public void onNext(Integer t) {
                 throw new TestException();
             }
         };
-        
+
         SerializedObserver<Integer> sobs = new SerializedObserver<Integer>(to);
-        
+
         try {
             sobs.onNext(0);
         } catch (TestException ex) {
             sobs.onError(ex);
         }
-        
+
         assertEquals(1, to.getOnErrorEvents().size());
         assertTrue(to.getOnErrorEvents().get(0) instanceof TestException);
     }
-    
+
     @Test
     public void testSerializeReentrantNullAndComplete() {
         final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>();
@@ -841,21 +841,21 @@ public void onNext(Integer t) {
                 throw new TestException();
             }
         };
-        
+
         SerializedObserver<Integer> sobs = new SerializedObserver<Integer>(to);
         serial.set(sobs);
-        
+
         try {
             sobs.onNext(0);
         } catch (TestException ex) {
             sobs.onError(ex);
         }
-        
+
         assertEquals(1, to.getOnErrorEvents().size());
         assertTrue(to.getOnErrorEvents().get(0) instanceof TestException);
         assertEquals(0, to.getCompletions());
     }
-    
+
     @Test
     public void testSerializeReentrantNullAndError() {
         final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>();
@@ -866,21 +866,21 @@ public void onNext(Integer t) {
                 throw new TestException();
             }
         };
-        
+
         SerializedObserver<Integer> sobs = new SerializedObserver<Integer>(to);
         serial.set(sobs);
-        
+
         try {
             sobs.onNext(0);
         } catch (TestException ex) {
             sobs.onError(ex);
         }
-        
+
         assertEquals(1, to.getOnErrorEvents().size());
         assertTrue(to.getOnErrorEvents().get(0) instanceof TestException);
         assertEquals(0, to.getCompletions());
     }
-    
+
     @Test
     public void testSerializeDrainPhaseThrows() {
         final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>();
@@ -896,21 +896,21 @@ public void onNext(Integer t) {
                 super.onNext(t);
             }
         };
-        
+
         SerializedObserver<Integer> sobs = new SerializedObserver<Integer>(to);
         serial.set(sobs);
-        
+
         sobs.onNext(0);
-        
+
         to.assertReceivedOnNext(Arrays.asList(0));
         assertEquals(1, to.getOnErrorEvents().size());
         assertTrue(to.getOnErrorEvents().get(0) instanceof TestException);
     }
-    
+
     @Test
     public void testErrorReentry() {
         final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>();
-       
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer v) {
@@ -921,16 +921,16 @@ public void onNext(Integer v) {
         };
         SerializedObserver<Integer> sobs = new SerializedObserver<Integer>(ts);
         serial.set(sobs);
-        
+
         sobs.onNext(1);
-        
+
         ts.assertValue(1);
         ts.assertError(TestException.class);
     }
     @Test
     public void testCompleteReentry() {
         final AtomicReference<Observer<Integer>> serial = new AtomicReference<Observer<Integer>>();
-       
+
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer v) {
@@ -941,9 +941,9 @@ public void onNext(Integer v) {
         };
         SerializedObserver<Integer> sobs = new SerializedObserver<Integer>(ts);
         serial.set(sobs);
-        
+
         sobs.onNext(1);
-        
+
         ts.assertValue(1);
         ts.assertCompleted();
         ts.assertNoErrors();
diff --git a/src/test/java/rx/observers/SubscribersTest.java b/src/test/java/rx/observers/SubscribersTest.java
index c98085c612..a55d250f48 100644
--- a/src/test/java/rx/observers/SubscribersTest.java
+++ b/src/test/java/rx/observers/SubscribersTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -32,7 +32,7 @@ public class SubscribersTest {
     public void constructorShouldBePrivate() {
         TestUtil.checkUtilityClass(Subscribers.class);
     }
-    
+
     @Test
     public void testEmptyOnErrorNotImplemented() {
         try {
@@ -68,7 +68,7 @@ public void testCreate2Null() {
     public void testCreate3Null() {
         Subscribers.create(Actions.empty(), null);
     }
-    
+
     @Test(expected = IllegalArgumentException.class)
     public void testCreate4Null() {
         Action1<Throwable> throwAction = Actions.empty();
@@ -83,7 +83,7 @@ public void testCreate6Null() {
         Action1<Throwable> throwAction = Actions.empty();
         Subscribers.create(Actions.empty(), throwAction, null);
     }
-    
+
     @Test
     public void testCreate1Value() {
         final AtomicInteger value = new AtomicInteger();
@@ -94,7 +94,7 @@ public void call(Integer t) {
             }
         };
         Subscribers.create(action).onNext(1);
-        
+
         assertEquals(1, value.get());
     }
     @Test
@@ -108,10 +108,10 @@ public void call(Integer t) {
         };
         Action1<Throwable> throwAction = Actions.empty();
         Subscribers.create(action, throwAction).onNext(1);
-        
+
         assertEquals(1, value.get());
     }
-    
+
     @Test
     public void testCreate3Value() {
         final AtomicInteger value = new AtomicInteger();
@@ -123,10 +123,10 @@ public void call(Integer t) {
         };
         Action1<Throwable> throwAction = Actions.empty();
         Subscribers.create(action, throwAction, Actions.empty()).onNext(1);
-        
+
         assertEquals(1, value.get());
     }
-    
+
     @Test
     public void testError2() {
         final AtomicReference<Throwable> value = new AtomicReference<Throwable>();
@@ -138,10 +138,10 @@ public void call(Throwable t) {
         };
         TestException exception = new TestException();
         Subscribers.create(Actions.empty(), action).onError(exception);
-        
+
         assertEquals(exception, value.get());
     }
-    
+
     @Test
     public void testError3() {
         final AtomicReference<Throwable> value = new AtomicReference<Throwable>();
@@ -153,14 +153,14 @@ public void call(Throwable t) {
         };
         TestException exception = new TestException();
         Subscribers.create(Actions.empty(), action, Actions.empty()).onError(exception);
-        
+
         assertEquals(exception, value.get());
     }
-    
+
     @Test
     public void testCompleted() {
         Action0 action = mock(Action0.class);
-        
+
         Action1<Throwable> throwAction = Actions.empty();
         Subscribers.create(Actions.empty(), throwAction, action).onCompleted();
 
@@ -169,30 +169,30 @@ public void testCompleted() {
     @Test
     public void testEmptyCompleted() {
         Subscribers.create(Actions.empty()).onCompleted();
-        
+
         Action1<Throwable> throwAction = Actions.empty();
         Subscribers.create(Actions.empty(), throwAction).onCompleted();
     }
-    
+
     @Test
     public void shareSubscriptionButNullSubscriber() {
         Subscriber<Integer> s = new Subscriber<Integer>(null, true) {
             @Override
             public void onNext(Integer t) {
-                
+
             }
-            
+
             @Override
             public void onError(Throwable e) {
-                
+
             }
-            
+
             @Override
             public void onCompleted() {
-                
+
             }
         };
-        
+
         s.add(Subscriptions.empty());
     }
 }
diff --git a/src/test/java/rx/observers/TestObserverTest.java b/src/test/java/rx/observers/TestObserverTest.java
index f1b26f1e56..cdf1d005ef 100644
--- a/src/test/java/rx/observers/TestObserverTest.java
+++ b/src/test/java/rx/observers/TestObserverTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -121,42 +121,42 @@ public void testWrappingMockWhenUnsubscribeInvolved() {
         inOrder.verify(mockObserver, times(1)).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
-    
+
     @Test
     public void testErrorSwallowed() {
         Observable.error(new RuntimeException()).subscribe(new TestObserver<Object>());
     }
-    
+
     @Test
     public void testGetEvents() {
         TestObserver<Integer> to = new TestObserver<Integer>();
         to.onNext(1);
         to.onNext(2);
-        
-        assertEquals(Arrays.<Object>asList(Arrays.asList(1, 2), 
-                Collections.emptyList(), 
+
+        assertEquals(Arrays.<Object>asList(Arrays.asList(1, 2),
+                Collections.emptyList(),
                 Collections.emptyList()), to.getEvents());
-        
+
         to.onCompleted();
-        
+
         assertEquals(Arrays.<Object>asList(Arrays.asList(1, 2), Collections.emptyList(),
                 Collections.singletonList(Notification.createOnCompleted())), to.getEvents());
-        
+
         TestException ex = new TestException();
         TestObserver<Integer> to2 = new TestObserver<Integer>();
         to2.onNext(1);
         to2.onNext(2);
-        
-        assertEquals(Arrays.<Object>asList(Arrays.asList(1, 2), 
-                Collections.emptyList(), 
+
+        assertEquals(Arrays.<Object>asList(Arrays.asList(1, 2),
+                Collections.emptyList(),
                 Collections.emptyList()), to2.getEvents());
-        
+
         to2.onError(ex);
-        
+
         assertEquals(Arrays.<Object>asList(
                 Arrays.asList(1, 2),
                 Collections.singletonList(ex),
-                Collections.emptyList()), 
+                Collections.emptyList()),
                     to2.getEvents());
     }
 
@@ -173,7 +173,7 @@ public void testNullExpected() {
         }
         fail("Null element check assertion didn't happen!");
     }
-    
+
     @Test
     public void testNullActual() {
         TestObserver<Integer> to = new TestObserver<Integer>();
@@ -187,13 +187,13 @@ public void testNullActual() {
         }
         fail("Null element check assertion didn't happen!");
     }
-    
+
     @Test
     public void testTerminalErrorOnce() {
         TestObserver<Integer> to = new TestObserver<Integer>();
         to.onError(new TestException());
         to.onError(new TestException());
-        
+
         try {
             to.assertTerminalEvent();
         } catch (AssertionError ex) {
@@ -207,7 +207,7 @@ public void testTerminalCompletedOnce() {
         TestObserver<Integer> to = new TestObserver<Integer>();
         to.onCompleted();
         to.onCompleted();
-        
+
         try {
             to.assertTerminalEvent();
         } catch (AssertionError ex) {
@@ -216,13 +216,13 @@ public void testTerminalCompletedOnce() {
         }
         fail("Failed to report multiple onError terminal events!");
     }
-    
+
     @Test
     public void testTerminalOneKind() {
         TestObserver<Integer> to = new TestObserver<Integer>();
         to.onError(new TestException());
         to.onCompleted();
-        
+
         try {
             to.assertTerminalEvent();
         } catch (AssertionError ex) {
diff --git a/src/test/java/rx/observers/TestSubscriberTest.java b/src/test/java/rx/observers/TestSubscriberTest.java
index c7d3c033c9..ee94f12297 100644
--- a/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/src/test/java/rx/observers/TestSubscriberTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -132,7 +132,7 @@ public void testAssertError() {
         Observable.error(e).subscribe(subscriber);
         subscriber.assertError(e);
     }
-    
+
     @Test
     public void testAwaitTerminalEventWithDuration() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
@@ -140,7 +140,7 @@ public void testAwaitTerminalEventWithDuration() {
         ts.awaitTerminalEvent(1, TimeUnit.SECONDS);
         ts.assertTerminalEvent();
     }
-    
+
     @Test
     public void testAwaitTerminalEventWithDurationAndUnsubscribeOnTimeout() {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
@@ -164,38 +164,38 @@ public void testNullDelegate1() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>((Observer<Integer>)null);
         ts.onCompleted();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void testNullDelegate2() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>((Subscriber<Integer>)null);
         ts.onCompleted();
     }
-    
+
     @Test(expected = NullPointerException.class)
     public void testNullDelegate3() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>((Subscriber<Integer>)null, 0);
         ts.onCompleted();
     }
-    
+
     @Test
     public void testDelegate1() {
         @SuppressWarnings("unchecked")
         Observer<Integer> to = mock(Observer.class);
         TestSubscriber<Integer> ts = TestSubscriber.create(to);
         ts.onCompleted();
-        
+
         verify(to).onCompleted();
     }
-    
+
     @Test
     public void testDelegate2() {
         TestSubscriber<Integer> ts1 = TestSubscriber.create();
         TestSubscriber<Integer> ts2 = TestSubscriber.create(ts1);
         ts2.onCompleted();
-        
+
         ts1.assertCompleted();
     }
-    
+
     @Test
     public void testDelegate3() {
         TestSubscriber<Integer> ts1 = TestSubscriber.create();
@@ -203,7 +203,7 @@ public void testDelegate3() {
         ts2.onCompleted();
         ts1.assertCompleted();
     }
-    
+
     @Test
     public void testUnsubscribed() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -215,7 +215,7 @@ public void testUnsubscribed() {
         }
         fail("Not unsubscribed but not reported!");
     }
-    
+
     @Test
     public void testNoErrors() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -228,7 +228,7 @@ public void testNoErrors() {
         }
         fail("Error present but no assertion error!");
     }
-    
+
     @Test
     public void testNotCompleted() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -240,7 +240,7 @@ public void testNotCompleted() {
         }
         fail("Not completed and no assertion error!");
     }
-    
+
     @Test
     public void testMultipleCompletions() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -254,7 +254,7 @@ public void testMultipleCompletions() {
         }
         fail("Multiple completions and no assertion error!");
     }
-    
+
     @Test
     public void testCompleted() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -267,7 +267,7 @@ public void testCompleted() {
         }
         fail("Completed and no assertion error!");
     }
-    
+
     @Test
     public void testMultipleCompletions2() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -281,7 +281,7 @@ public void testMultipleCompletions2() {
         }
         fail("Multiple completions and no assertion error!");
     }
-    
+
     @Test
     public void testMultipleErrors() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -298,7 +298,7 @@ public void testMultipleErrors() {
         }
         fail("Multiple Error present but no assertion error!");
     }
-    
+
     @Test
     public void testMultipleErrors2() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -315,7 +315,7 @@ public void testMultipleErrors2() {
         }
         fail("Multiple Error present but no assertion error!");
     }
-    
+
     @Test
     public void testMultipleErrors3() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -332,7 +332,7 @@ public void testMultipleErrors3() {
         }
         fail("Multiple Error present but no assertion error!");
     }
-    
+
     @Test
     public void testDifferentError() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -345,7 +345,7 @@ public void testDifferentError() {
         }
         fail("Different Error present but no assertion error!");
     }
-    
+
     @Test
     public void testDifferentError2() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -358,7 +358,7 @@ public void testDifferentError2() {
         }
         fail("Different Error present but no assertion error!");
     }
-    
+
     @Test
     public void testDifferentError3() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -371,7 +371,7 @@ public void testDifferentError3() {
         }
         fail("Different Error present but no assertion error!");
     }
-    
+
     @Test
     public void testNoError() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -395,7 +395,7 @@ public void testNoError2() {
         }
         fail("No present but no assertion error!");
     }
-    
+
     @Test
     public void testInterruptTerminalEventAwait() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -409,7 +409,7 @@ public void call() {
                     t0.interrupt();
                 }
             }, 200, TimeUnit.MILLISECONDS);
-            
+
             try {
                 ts.awaitTerminalEvent();
                 fail("Did not interrupt wait!");
@@ -422,7 +422,7 @@ public void call() {
             w.unsubscribe();
         }
     }
-    
+
     @Test
     public void testInterruptTerminalEventAwaitTimed() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -436,7 +436,7 @@ public void call() {
                     t0.interrupt();
                 }
             }, 200, TimeUnit.MILLISECONDS);
-            
+
             try {
                 ts.awaitTerminalEvent(5, TimeUnit.SECONDS);
                 fail("Did not interrupt wait!");
@@ -449,7 +449,7 @@ public void call() {
             w.unsubscribe();
         }
     }
-    
+
     @Test
     public void testInterruptTerminalEventAwaitAndUnsubscribe() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
@@ -463,7 +463,7 @@ public void call() {
                     t0.interrupt();
                 }
             }, 200, TimeUnit.MILLISECONDS);
-            
+
             ts.awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
             if (!ts.isUnsubscribed()) {
                 fail("Did not unsubscribe!");
@@ -472,13 +472,13 @@ public void call() {
             w.unsubscribe();
         }
     }
-    
+
     @Test
     public void testNoTerminalEventBut1Completed() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         ts.onCompleted();
-        
+
         try {
             ts.assertNoTerminalEvent();
             fail("Failed to report there were terminal event(s)!");
@@ -486,13 +486,13 @@ public void testNoTerminalEventBut1Completed() {
             // expected
         }
     }
-    
+
     @Test
     public void testNoTerminalEventBut1Error() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         ts.onError(new TestException());
-        
+
         try {
             ts.assertNoTerminalEvent();
             fail("Failed to report there were terminal event(s)!");
@@ -500,14 +500,14 @@ public void testNoTerminalEventBut1Error() {
             // expected
         }
     }
-    
+
     @Test
     public void testNoTerminalEventBut1Error1Completed() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         ts.onCompleted();
         ts.onError(new TestException());
-        
+
         try {
             ts.assertNoTerminalEvent();
             fail("Failed to report there were terminal event(s)!");
@@ -515,14 +515,14 @@ public void testNoTerminalEventBut1Error1Completed() {
             // expected
         }
     }
-    
+
     @Test
     public void testNoTerminalEventBut2Errors() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         ts.onError(new TestException());
         ts.onError(new TestException());
-        
+
         try {
             ts.assertNoTerminalEvent();
             fail("Failed to report there were terminal event(s)!");
@@ -533,12 +533,12 @@ public void testNoTerminalEventBut2Errors() {
             }
         }
     }
-    
+
     @Test
     public void testNoValues() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
         ts.onNext(1);
-        
+
         try {
             ts.assertNoValues();
             fail("Failed to report there were values!");
@@ -546,13 +546,13 @@ public void testNoValues() {
             // expected
         }
     }
-    
+
     @Test
     public void testValueCount() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
         ts.onNext(1);
         ts.onNext(2);
-        
+
         try {
             ts.assertValueCount(3);
             fail("Failed to report there were values!");
@@ -560,7 +560,7 @@ public void testValueCount() {
             // expected
         }
     }
-    
+
     @Test(timeout = 1000)
     public void testOnCompletedCrashCountsDownLatch() {
         Observer<Integer> to = new Observer<Integer>() {
@@ -571,25 +571,25 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                
+
             }
 
             @Override
             public void onNext(Integer t) {
-                
+
             }
         };
         TestSubscriber<Integer> ts = TestSubscriber.create(to);
-        
+
         try {
             ts.onCompleted();
         } catch (TestException ex) {
             // expected
         }
-        
+
         ts.awaitTerminalEvent();
     }
-    
+
     @Test(timeout = 5000)
     public void testOnErrorCrashCountsDownLatch() {
         Observer<Integer> to = new Observer<Integer>() {
@@ -600,22 +600,22 @@ public void onError(Throwable e) {
 
             @Override
             public void onCompleted() {
-                
+
             }
 
             @Override
             public void onNext(Integer t) {
-                
+
             }
         };
         TestSubscriber<Integer> ts = TestSubscriber.create(to);
-        
+
         try {
             ts.onError(new RuntimeException());
         } catch (TestException ex) {
             // expected
         }
-        
+
         ts.awaitTerminalEvent();
     }
 
@@ -638,7 +638,7 @@ public void assertValuesShouldThrowIfNumberOfItemsDoesNotMatch() {
             );
         }
     }
-    
+
     @Test
     public void assertionFailureGivesActiveDetails() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
@@ -662,7 +662,7 @@ public void assertionFailureGivesActiveDetails() {
             assertEquals("forced failure", ex.getMessage());
         }
     }
-    
+
     @Test
     public void assertionFailureShowsMultipleErrors() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
@@ -741,78 +741,78 @@ public void completionCount() {
         Assert.assertEquals(0, ts.getCompletions());
 
         ts.onCompleted();
-        
+
         Assert.assertEquals(1, ts.getCompletions());
 
         ts.onCompleted();
-        
+
         Assert.assertEquals(2, ts.getCompletions());
     }
-    
+
     @Test
     public void awaitValueCount() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 5).delay(100, TimeUnit.MILLISECONDS)
         .subscribe(ts);
-        
+
         Assert.assertTrue(ts.awaitValueCount(2, 5, TimeUnit.SECONDS));
-        
+
         Assert.assertEquals(1, ts.getOnNextEvents().get(0).intValue());
         Assert.assertEquals(2, ts.getOnNextEvents().get(1).intValue());
     }
-    
+
     @Test
     public void awaitValueCountFails() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(1, 2).delay(100, TimeUnit.MILLISECONDS)
         .subscribe(ts);
-        
+
         Assert.assertFalse(ts.awaitValueCount(5, 1, TimeUnit.SECONDS));
-        
+
     }
-    
+
     @Test
     public void assertAndConsume() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         ts.assertNoValues();
-        
+
         ts.onNext(1);
-        
+
         ts.assertValuesAndClear(1);
-        
+
         ts.assertNoValues();
-        
+
         ts.onNext(2);
         ts.onNext(3);
-        
+
         ts.assertValueCount(2);
-        
+
         ts.assertValuesAndClear(2, 3);
-        
+
         ts.onNext(4);
         ts.onNext(5);
-        
+
         try {
             ts.assertValuesAndClear(4);
             Assert.fail("Should have thrown AssertionError");
         } catch (AssertionError ex) {
             // expected
         }
-        
+
         ts.assertValueCount(2);
-        
+
         try {
             ts.assertValuesAndClear(4, 5, 6);
             Assert.fail("Should have thrown AssertionError");
         } catch (AssertionError ex) {
             // expected
         }
-        
+
         ts.assertValuesAndClear(4, 5);
-        
+
         ts.assertNoValues();
     }
 }
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index ff21d14bc6..b9fc370d69 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -48,7 +48,7 @@ public Integer call(Integer t) {
             }
         });
     }
-    
+
     @Test
     public void constructorShouldBePrivate() {
         TestUtil.checkUtilityClass(RxJavaHooks.class);
@@ -59,29 +59,29 @@ public void assemblyTrackingObservable() {
         RxJavaHooks.enableAssemblyTracking();
         try {
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             createObservable().subscribe(ts);
-            
+
             ts.assertError(TestException.class);
-            
+
             Throwable ex = ts.getOnErrorEvents().get(0);
-            
+
             AssemblyStackTraceException aste = AssemblyStackTraceException.find(ex);
-            
+
             assertNotNull(aste);
-            
+
             assertTrue(aste.getMessage(), aste.getMessage().contains("createObservable"));
-            
+
             RxJavaHooks.clearAssemblyTracking();
 
             ts = TestSubscriber.create();
-            
+
             createObservable().subscribe(ts);
 
             ts.assertError(TestException.class);
-            
+
             ex = ts.getOnErrorEvents().get(0);
-            
+
             aste = AssemblyStackTraceException.find(ex);
 
             assertNull(aste);
@@ -89,7 +89,7 @@ public void assemblyTrackingObservable() {
             RxJavaHooks.resetAssemblyTracking();
         }
     }
-    
+
     static Single<Integer> createSingle() {
         return Single.just(1).map(new Func1<Integer, Integer>() {
             @Override
@@ -98,35 +98,35 @@ public Integer call(Integer t) {
             }
         });
     }
-    
+
     @Test
     public void assemblyTrackingSingle() {
         RxJavaHooks.enableAssemblyTracking();
         try {
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             createSingle().subscribe(ts);
-            
+
             ts.assertError(TestException.class);
-            
+
             Throwable ex = ts.getOnErrorEvents().get(0);
-            
+
             AssemblyStackTraceException aste = AssemblyStackTraceException.find(ex);
-            
+
             assertNotNull(aste);
-            
+
             assertTrue(aste.getMessage(), aste.getMessage().contains("createSingle"));
 
             RxJavaHooks.clearAssemblyTracking();
 
             ts = TestSubscriber.create();
-            
+
             createSingle().subscribe(ts);
 
             ts.assertError(TestException.class);
-            
+
             ex = ts.getOnErrorEvents().get(0);
-            
+
             aste = AssemblyStackTraceException.find(ex);
 
             assertNull(aste);
@@ -134,7 +134,7 @@ public void assemblyTrackingSingle() {
             RxJavaHooks.resetAssemblyTracking();
         }
     }
-    
+
     static Completable createCompletable() {
         return Completable.error(new Func0<Throwable>() {
             @Override
@@ -143,44 +143,44 @@ public Throwable call() {
             }
         });
     }
-    
+
     @Test
     public void assemblyTrackingCompletable() {
         RxJavaHooks.enableAssemblyTracking();
         try {
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             createCompletable().subscribe(ts);
-            
+
             ts.assertError(TestException.class);
-            
+
             Throwable ex = ts.getOnErrorEvents().get(0);
-            
+
             AssemblyStackTraceException aste = AssemblyStackTraceException.find(ex);
-            
+
             assertNotNull(aste);
-            
+
             assertTrue(aste.getMessage(), aste.getMessage().contains("createCompletable"));
 
             RxJavaHooks.clearAssemblyTracking();
 
             ts = TestSubscriber.create();
-            
+
             createCompletable().subscribe(ts);
 
             ts.assertError(TestException.class);
 
             ex = ts.getOnErrorEvents().get(0);
-            
+
             aste = AssemblyStackTraceException.find(ex);
 
             assertNull(aste);
-            
+
         } finally {
             RxJavaHooks.resetAssemblyTracking();
         }
     }
-    
+
     @SuppressWarnings("rawtypes")
     @Test
     public void lockdown() throws Exception {
@@ -202,14 +202,14 @@ public Object call(Object t1, Object t2) {
                     return t2;
                 }
             };
-            
+
             for (Method m : RxJavaHooks.class.getMethods()) {
                 if (m.getName().startsWith("setOn")) {
-                    
+
                     Method getter = RxJavaHooks.class.getMethod("get" + m.getName().substring(3));
-                    
+
                     Object before = getter.invoke(null);
-                    
+
                     if (m.getParameterTypes()[0].isAssignableFrom(Func0.class)) {
                         m.invoke(null, f0);
                     } else
@@ -221,11 +221,11 @@ public Object call(Object t1, Object t2) {
                     } else {
                         m.invoke(null, f2);
                     }
-                    
+
                     Object after = getter.invoke(null);
-                    
+
                     assertSame(m.toString(), before, after);
-                    
+
                     if (before != null) {
                         RxJavaHooks.clear();
                         RxJavaHooks.reset();
@@ -233,40 +233,40 @@ public Object call(Object t1, Object t2) {
                     }
                 }
             }
-            
-            
+
+
             Object o1 = RxJavaHooks.getOnObservableCreate();
             Object o2 = RxJavaHooks.getOnSingleCreate();
             Object o3 = RxJavaHooks.getOnCompletableCreate();
-            
+
             RxJavaHooks.enableAssemblyTracking();
             RxJavaHooks.clearAssemblyTracking();
             RxJavaHooks.resetAssemblyTracking();
 
-            
+
             assertSame(o1, RxJavaHooks.getOnObservableCreate());
             assertSame(o2, RxJavaHooks.getOnSingleCreate());
             assertSame(o3, RxJavaHooks.getOnCompletableCreate());
-            
+
         } finally {
             RxJavaHooks.lockdown = false;
             RxJavaHooks.reset();
             assertFalse(RxJavaHooks.isLockdown());
         }
     }
-    
+
     Func1<Scheduler, Scheduler> replaceWithImmediate = new Func1<Scheduler, Scheduler>() {
         @Override
         public Scheduler call(Scheduler t) {
             return Schedulers.immediate();
         }
     };
-    
+
     @Test
     public void overrideComputationScheduler() {
         try {
             RxJavaHooks.setOnComputationScheduler(replaceWithImmediate);
-            
+
             assertSame(Schedulers.immediate(), Schedulers.computation());
         } finally {
             RxJavaHooks.reset();
@@ -279,7 +279,7 @@ public void overrideComputationScheduler() {
     public void overrideIoScheduler() {
         try {
             RxJavaHooks.setOnIOScheduler(replaceWithImmediate);
-            
+
             assertSame(Schedulers.immediate(), Schedulers.io());
         } finally {
             RxJavaHooks.reset();
@@ -292,7 +292,7 @@ public void overrideIoScheduler() {
     public void overrideNewThreadScheduler() {
         try {
             RxJavaHooks.setOnNewThreadScheduler(replaceWithImmediate);
-            
+
             assertSame(Schedulers.immediate(), Schedulers.newThread());
         } finally {
             RxJavaHooks.reset();
@@ -311,11 +311,11 @@ public Observable.OnSubscribe call(Observable.OnSubscribe t) {
                     return new OnSubscribeRange(1, 2);
                 }
             });
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             Observable.range(10, 3).subscribe(ts);
-            
+
             ts.assertValues(1, 2);
             ts.assertNoErrors();
             ts.assertCompleted();
@@ -324,14 +324,14 @@ public Observable.OnSubscribe call(Observable.OnSubscribe t) {
         }
         // make sure the reset worked
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(10, 3).subscribe(ts);
-        
+
         ts.assertValues(10, 11, 12);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings("rawtypes")
     @Test
     public void observableStart() {
@@ -342,11 +342,11 @@ public Observable.OnSubscribe call(Observable o, Observable.OnSubscribe t) {
                     return new OnSubscribeRange(1, 2);
                 }
             });
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             Observable.range(10, 3).subscribe(ts);
-            
+
             ts.assertValues(1, 2);
             ts.assertNoErrors();
             ts.assertCompleted();
@@ -355,34 +355,34 @@ public Observable.OnSubscribe call(Observable o, Observable.OnSubscribe t) {
         }
         // make sure the reset worked
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Observable.range(10, 3).subscribe(ts);
-        
+
         ts.assertValues(10, 11, 12);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void observableReturn() {
         try {
             final Subscription s = Subscriptions.empty();
-            
+
             RxJavaHooks.setOnObservableReturn(new Func1<Subscription, Subscription>() {
                 @Override
                 public Subscription call(Subscription t) {
                     return s;
                 }
             });
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             Subscription u = Observable.range(10, 3).subscribe(ts);
-            
+
             ts.assertValues(10, 11, 12);
             ts.assertNoErrors();
             ts.assertCompleted();
-            
+
             assertSame(s, u);
         } finally {
             RxJavaHooks.reset();
@@ -404,11 +404,11 @@ public void call(SingleSubscriber<? super Object> t) {
                     };
                 }
             });
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             Single.just(1).subscribe(ts);
-            
+
             ts.assertValue(10);
             ts.assertNoErrors();
             ts.assertCompleted();
@@ -417,14 +417,14 @@ public void call(SingleSubscriber<? super Object> t) {
         }
         // make sure the reset worked
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Single.just(1).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @SuppressWarnings("rawtypes")
     @Test
     public void singleStart() {
@@ -440,11 +440,11 @@ public void call(Subscriber<? super Object> t) {
                     };
                 }
             });
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             Single.just(1).subscribe(ts);
-            
+
             ts.assertValue(10);
             ts.assertNoErrors();
             ts.assertCompleted();
@@ -453,34 +453,34 @@ public void call(Subscriber<? super Object> t) {
         }
         // make sure the reset worked
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Single.just(1).subscribe(ts);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void singleReturn() {
         try {
             final Subscription s = Subscriptions.empty();
-            
+
             RxJavaHooks.setOnSingleReturn(new Func1<Subscription, Subscription>() {
                 @Override
                 public Subscription call(Subscription t) {
                     return s;
                 }
             });
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             Subscription u = Single.just(1).subscribe(ts);
-            
+
             ts.assertValue(1);
             ts.assertNoErrors();
             ts.assertCompleted();
-            
+
             assertSame(s, u);
         } finally {
             RxJavaHooks.reset();
@@ -501,11 +501,11 @@ public void call(CompletableSubscriber t) {
                     };
                 }
             });
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             Completable.complete().subscribe(ts);
-            
+
             ts.assertNoValues();
             ts.assertNotCompleted();
             ts.assertError(TestException.class);
@@ -514,14 +514,14 @@ public void call(CompletableSubscriber t) {
         }
         // make sure the reset worked
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Completable.complete().subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
     }
-    
+
     @Test
     public void completableStart() {
         try {
@@ -536,11 +536,11 @@ public void call(CompletableSubscriber t) {
                     };
                 }
             });
-            
+
             TestSubscriber<Integer> ts = TestSubscriber.create();
-            
+
             Completable.complete().subscribe(ts);
-            
+
             ts.assertNoValues();
             ts.assertNotCompleted();
             ts.assertError(TestException.class);
@@ -549,9 +549,9 @@ public void call(CompletableSubscriber t) {
         }
         // make sure the reset worked
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        
+
         Completable.complete().subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -562,7 +562,7 @@ void onSchedule(Worker w) throws InterruptedException {
             try {
                 final AtomicInteger value = new AtomicInteger();
                 final CountDownLatch cdl = new CountDownLatch(1);
-                
+
                 RxJavaHooks.setOnScheduleAction(new Func1<Action0, Action0>() {
                     @Override
                     public Action0 call(Action0 t) {
@@ -575,7 +575,7 @@ public void call() {
                         };
                     }
                 });
-                
+
                 w.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -583,20 +583,20 @@ public void call() {
                         cdl.countDown();
                     }
                 });
-                
+
                 cdl.await();
-                
+
                 assertEquals(10, value.get());
-                
+
             } finally {
-                
+
                 RxJavaHooks.reset();
             }
-            
+
             // make sure the reset worked
             final AtomicInteger value = new AtomicInteger();
             final CountDownLatch cdl = new CountDownLatch(1);
-            
+
             w.schedule(new Action0() {
                 @Override
                 public void call() {
@@ -604,15 +604,15 @@ public void call() {
                     cdl.countDown();
                 }
             });
-            
+
             cdl.await();
-            
+
             assertEquals(1, value.get());
         } finally {
             w.unsubscribe();
         }
     }
-    
+
     @Test
     public void onScheduleComputation() throws InterruptedException {
         onSchedule(Schedulers.computation().createWorker());
@@ -632,23 +632,23 @@ public void onScheduleNewThread() throws InterruptedException {
     public void onError() {
         try {
             final List<Throwable> list = new ArrayList<Throwable>();
-            
+
             RxJavaHooks.setOnError(new Action1<Throwable>() {
                 @Override
                 public void call(Throwable t) {
                     list.add(t);
                 }
             });
-            
+
             RxJavaHooks.onError(new TestException("Forced failure"));
-            
+
             assertEquals(1, list.size());
             assertTestException(list, 0, "Forced failure");
         } finally {
             RxJavaHooks.reset();
         }
     }
-    
+
     @Test
     public void clear() throws Exception {
         RxJavaHooks.reset();
@@ -665,7 +665,7 @@ public void clear() throws Exception {
         }
 
         for (Method m : RxJavaHooks.class.getMethods()) {
-            if (m.getName().startsWith("getOn") 
+            if (m.getName().startsWith("getOn")
                     && !m.getName().endsWith("Scheduler")
                     && !m.getName().contains("GenericScheduledExecutorService")) {
                 assertNotNull(m.toString(), m.invoke(null));
@@ -678,18 +678,18 @@ public void clear() throws Exception {
     public void onErrorNoHandler() {
         try {
             final List<Throwable> list = new ArrayList<Throwable>();
-            
+
             RxJavaHooks.setOnError(null);
-            
+
             Thread.currentThread().setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
-                
+
                 @Override
                 public void uncaughtException(Thread t, Throwable e) {
                     list.add(e);
-                    
+
                 }
             });
-            
+
             RxJavaHooks.onError(new TestException("Forced failure"));
 
             Thread.currentThread().setUncaughtExceptionHandler(null);
@@ -709,7 +709,7 @@ public void uncaughtException(Thread t, Throwable e) {
     public void onErrorCrashes() {
         try {
             final List<Throwable> list = new ArrayList<Throwable>();
-            
+
             RxJavaHooks.setOnError(new Action1<Throwable>() {
                 @Override
                 public void call(Throwable t) {
@@ -718,22 +718,22 @@ public void call(Throwable t) {
             });
 
             Thread.currentThread().setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
-                
+
                 @Override
                 public void uncaughtException(Thread t, Throwable e) {
                     list.add(e);
-                    
+
                 }
             });
 
             RxJavaHooks.onError(new TestException("Forced failure"));
-            
+
             assertEquals(2, list.size());
             assertTestException(list, 0, "Forced failure 2");
             assertTestException(list, 1, "Forced failure");
 
             Thread.currentThread().setUncaughtExceptionHandler(null);
-            
+
         } finally {
             RxJavaHooks.reset();
             Thread.currentThread().setUncaughtExceptionHandler(null);
@@ -745,81 +745,81 @@ public void uncaughtException(Thread t, Throwable e) {
     public void clearIsPassthrough() {
         try {
             RxJavaHooks.clear();
-            
+
             assertNull(RxJavaHooks.onCreate((Observable.OnSubscribe)null));
 
             Observable.OnSubscribe oos = new Observable.OnSubscribe() {
                 @Override
                 public void call(Object t) {
-                    
+
                 }
             };
 
             assertSame(oos, RxJavaHooks.onCreate(oos));
-            
+
             assertNull(RxJavaHooks.onCreate((Single.OnSubscribe)null));
 
             Single.OnSubscribe sos = new Single.OnSubscribe() {
                 @Override
                 public void call(Object t) {
-                    
+
                 }
             };
 
             assertSame(sos, RxJavaHooks.onCreate(sos));
-            
+
             assertNull(RxJavaHooks.onCreate((Single.OnSubscribe)null));
 
             Completable.OnSubscribe cos = new Completable.OnSubscribe() {
                 @Override
                 public void call(CompletableSubscriber t) {
-                    
+
                 }
             };
 
             assertSame(cos, RxJavaHooks.onCreate(cos));
-            
+
             assertNull(RxJavaHooks.onScheduledAction(null));
-            
+
             Action0 action = Actions.empty();
-            
+
             assertSame(action, RxJavaHooks.onScheduledAction(action));
-            
-            
+
+
             assertNull(RxJavaHooks.onObservableStart(Observable.never(), null));
-            
+
             assertSame(oos, RxJavaHooks.onObservableStart(Observable.never(), oos));
 
             assertNull(RxJavaHooks.onSingleStart(Single.just(1), null));
-            
+
             assertSame(oos, RxJavaHooks.onSingleStart(Single.just(1), oos));
 
             assertNull(RxJavaHooks.onCompletableStart(Completable.never(), null));
-            
+
             assertSame(cos, RxJavaHooks.onCompletableStart(Completable.never(), cos));
-            
+
             Subscription subscription = Subscriptions.empty();
-            
+
             assertNull(RxJavaHooks.onObservableReturn(null));
-            
+
             assertSame(subscription, RxJavaHooks.onObservableReturn(subscription));
 
             assertNull(RxJavaHooks.onSingleReturn(null));
-            
+
             assertSame(subscription, RxJavaHooks.onSingleReturn(subscription));
 
             TestException ex = new TestException();
-            
+
             assertNull(RxJavaHooks.onObservableError(null));
-            
+
             assertSame(ex, RxJavaHooks.onObservableError(ex));
 
             assertNull(RxJavaHooks.onSingleError(null));
-            
+
             assertSame(ex, RxJavaHooks.onSingleError(ex));
 
             assertNull(RxJavaHooks.onCompletableError(null));
-            
+
             assertSame(ex, RxJavaHooks.onCompletableError(ex));
 
             Observable.Operator oop = new Observable.Operator() {
@@ -828,43 +828,43 @@ public Object call(Object t) {
                     return t;
                 }
             };
-            
+
             assertNull(RxJavaHooks.onObservableLift(null));
-            
+
             assertSame(oop, RxJavaHooks.onObservableLift(oop));
-            
+
             assertNull(RxJavaHooks.onSingleLift(null));
-            
+
             assertSame(oop, RxJavaHooks.onSingleLift(oop));
-            
+
             Completable.Operator cop = new Completable.Operator() {
                 @Override
                 public CompletableSubscriber call(CompletableSubscriber t) {
                     return t;
                 }
             };
-            
+
             assertNull(RxJavaHooks.onCompletableLift(null));
-            
+
             assertSame(cop, RxJavaHooks.onCompletableLift(cop));
-            
+
         } finally {
             RxJavaHooks.reset();
         }
     }
-    
+
     static void assertTestException(List<Throwable> list, int index, String message) {
         assertTrue(list.get(index).toString(), list.get(index) instanceof TestException);
         assertEquals(message, list.get(index).getMessage());
     }
-    
+
     @Test
     public void onXError() {
         try {
             final List<Throwable> list = new ArrayList<Throwable>();
-            
+
             final TestException ex = new TestException();
-            
+
             Func1<Throwable, Throwable> errorHandler = new Func1<Throwable, Throwable>() {
                 @Override
                 public Throwable call(Throwable t) {
@@ -872,7 +872,7 @@ public Throwable call(Throwable t) {
                     return ex;
                 }
             };
-            
+
             RxJavaHooks.setOnObservableSubscribeError(errorHandler);
 
             RxJavaHooks.setOnSingleSubscribeError(errorHandler);
@@ -882,11 +882,11 @@ public Throwable call(Throwable t) {
             assertSame(ex, RxJavaHooks.onObservableError(new TestException("Forced failure 1")));
 
             assertSame(ex, RxJavaHooks.onSingleError(new TestException("Forced failure 2")));
-            
+
             assertSame(ex, RxJavaHooks.onCompletableError(new TestException("Forced failure 3")));
-            
+
             assertTestException(list, 0, "Forced failure 1");
-            
+
             assertTestException(list, 1, "Forced failure 2");
 
             assertTestException(list, 2, "Forced failure 3");
@@ -901,11 +901,11 @@ public void onPluginsXError() {
         try {
             RxJavaPlugins.getInstance().reset();
             RxJavaHooks.reset();
-            
+
             final List<Throwable> list = new ArrayList<Throwable>();
-            
+
             final TestException ex = new TestException();
-            
+
             final Func1<Throwable, Throwable> errorHandler = new Func1<Throwable, Throwable>() {
                 @Override
                 public Throwable call(Throwable t) {
@@ -938,11 +938,11 @@ public Throwable onSubscribeError(Throwable e) {
             assertSame(ex, RxJavaHooks.onObservableError(new TestException("Forced failure 1")));
 
             assertSame(ex, RxJavaHooks.onSingleError(new TestException("Forced failure 2")));
-            
+
             assertSame(ex, RxJavaHooks.onCompletableError(new TestException("Forced failure 3")));
-            
+
             assertTestException(list, 0, "Forced failure 1");
-            
+
             assertTestException(list, 1, "Forced failure 2");
 
             assertTestException(list, 2, "Forced failure 3");
@@ -962,7 +962,7 @@ public CompletableSubscriber call(CompletableSubscriber t) {
                     return t;
                 }
             };
-            
+
             Observable.Operator oop = new Observable.Operator() {
                 @Override
                 public Object call(Object t) {
@@ -995,13 +995,13 @@ public Completable.Operator call(Completable.Operator t) {
                     return t;
                 }
             });
-            
+
             assertSame(oop, RxJavaHooks.onObservableLift(oop));
 
             assertSame(oop, RxJavaHooks.onSingleLift(oop));
 
             assertSame(cop, RxJavaHooks.onCompletableLift(cop));
-            
+
             assertEquals(3, counter[0]);
 
         } finally {
@@ -1013,7 +1013,7 @@ public Completable.Operator call(Completable.Operator t) {
     @Test
     public void onPluginsXLift() {
         try {
-            
+
             RxJavaPlugins.getInstance().reset();
             RxJavaHooks.reset();
 
@@ -1023,7 +1023,7 @@ public CompletableSubscriber call(CompletableSubscriber t) {
                     return t;
                 }
             };
-            
+
             Observable.Operator oop = new Observable.Operator() {
                 @Override
                 public Object call(Object t) {
@@ -1048,34 +1048,34 @@ public Completable.Operator call(Completable.Operator t) {
                     return t;
                 }
             };
-            
+
             RxJavaPlugins.getInstance().registerObservableExecutionHook(new RxJavaObservableExecutionHook() {
                 @Override
                 public <T, R> Observable.Operator<? extends R, ? super T> onLift(Observable.Operator<? extends R, ? super T> lift) {
                     return onObservableLift.call(lift);
                 }
             });
-            
+
             RxJavaPlugins.getInstance().registerSingleExecutionHook(new RxJavaSingleExecutionHook() {
                 @Override
                 public <T, R> Observable.Operator<? extends R, ? super T> onLift(Observable.Operator<? extends R, ? super T> lift) {
                     return onObservableLift.call(lift);
                 }
             });
-            
+
             RxJavaPlugins.getInstance().registerCompletableExecutionHook(new RxJavaCompletableExecutionHook() {
                 @Override
                 public Completable.Operator onLift(Completable.Operator lift) {
                     return onCompletableLift.call(lift);
                 }
             });
-            
+
             assertSame(oop, RxJavaHooks.onObservableLift(oop));
 
             assertSame(oop, RxJavaHooks.onSingleLift(oop));
 
             assertSame(cop, RxJavaHooks.onCompletableLift(cop));
-            
+
             assertEquals(3, counter[0]);
 
         } finally {
diff --git a/src/test/java/rx/plugins/RxJavaPluginsTest.java b/src/test/java/rx/plugins/RxJavaPluginsTest.java
index b8a1a13bf7..ebcee62325 100644
--- a/src/test/java/rx/plugins/RxJavaPluginsTest.java
+++ b/src/test/java/rx/plugins/RxJavaPluginsTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -263,31 +263,31 @@ private static String getFullClassNameForTestClass(Class<?> cls) {
         return RxJavaPlugins.class.getPackage()
                                   .getName() + "." + RxJavaPluginsTest.class.getSimpleName() + "$" + cls.getSimpleName();
     }
-    
+
     @Test
     public void testShortPluginDiscovery() {
         Properties props = new Properties();
-        
+
         props.setProperty("rxjava.plugin.1.class", "Map");
         props.setProperty("rxjava.plugin.1.impl", "java.util.HashMap");
 
         props.setProperty("rxjava.plugin.xyz.class", "List");
         props.setProperty("rxjava.plugin.xyz.impl", "java.util.ArrayList");
 
-        
+
         Object o = RxJavaPlugins.getPluginImplementationViaProperty(Map.class, props);
-        
+
         assertTrue("" + o, o instanceof HashMap);
-        
+
         o = RxJavaPlugins.getPluginImplementationViaProperty(List.class, props);
-        
+
         assertTrue("" + o, o instanceof ArrayList);
     }
-    
+
     @Test(expected = RuntimeException.class)
     public void testShortPluginDiscoveryMissing() {
         Properties props = new Properties();
-        
+
         props.setProperty("rxjava.plugin.1.class", "Map");
 
         RxJavaPlugins.getPluginImplementationViaProperty(Map.class, props);
diff --git a/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 461ff7cce2..5e5686b396 100644
--- a/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -42,9 +42,9 @@
 
 /**
  * Base tests for schedulers that involve threads (concurrency).
- * 
+ *
  * These can only run on Schedulers that launch threads since they expect async/concurrent behavior.
- * 
+ *
  * The Current/Immediate schedulers will not work with these tests.
  */
 public abstract class AbstractSchedulerConcurrencyTests extends AbstractSchedulerTests {
@@ -106,13 +106,13 @@ public void testUnsubscribeRecursiveScheduleFromOutside() throws InterruptedExce
         final Worker inner = getScheduler().createWorker();
         try {
             inner.schedule(new Action0() {
-    
+
                 @Override
                 public void call() {
                     inner.schedule(new Action0() {
-    
+
                         int i = 0;
-    
+
                         @Override
                         public void call() {
                             System.out.println("Run: " + i++);
@@ -123,20 +123,20 @@ public void call() {
                                     unsubscribeLatch.await();
                                 } catch (InterruptedException e) {
                                     // we expect the countDown if unsubscribe is not working
-                                    // or to be interrupted if unsubscribe is successful since 
+                                    // or to be interrupted if unsubscribe is successful since
                                     // the unsubscribe will interrupt it as it is calling Future.cancel(true)
                                     // so we will ignore the stacktrace
                                 }
                             }
-    
+
                             counter.incrementAndGet();
                             inner.schedule(this);
                         }
                     });
                 }
-    
+
             });
-    
+
             latch.await();
             inner.unsubscribe();
             unsubscribeLatch.countDown();
@@ -154,28 +154,28 @@ public void testUnsubscribeRecursiveScheduleFromInside() throws InterruptedExcep
         final Worker inner = getScheduler().createWorker();
         try {
             inner.schedule(new Action0() {
-    
+
                 @Override
                 public void call() {
                     inner.schedule(new Action0() {
-    
+
                         int i = 0;
-    
+
                         @Override
                         public void call() {
                             System.out.println("Run: " + i++);
                             if (i == 10) {
                                 inner.unsubscribe();
                             }
-    
+
                             counter.incrementAndGet();
                             inner.schedule(this);
                         }
                     });
                 }
-    
+
             });
-    
+
             unsubscribeLatch.countDown();
             Thread.sleep(200); // let time pass to see if the scheduler is still doing work
             assertEquals(10, counter.get());
@@ -190,16 +190,16 @@ public void testUnsubscribeRecursiveScheduleWithDelay() throws InterruptedExcept
         final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
         final AtomicInteger counter = new AtomicInteger();
         final Worker inner = getScheduler().createWorker();
-        
+
         try {
             inner.schedule(new Action0() {
-    
+
                 @Override
                 public void call() {
                     inner.schedule(new Action0() {
-    
+
                         long i = 1L;
-    
+
                         @Override
                         public void call() {
                             if (i++ == 10) {
@@ -209,19 +209,19 @@ public void call() {
                                     unsubscribeLatch.await();
                                 } catch (InterruptedException e) {
                                     // we expect the countDown if unsubscribe is not working
-                                    // or to be interrupted if unsubscribe is successful since 
+                                    // or to be interrupted if unsubscribe is successful since
                                     // the unsubscribe will interrupt it as it is calling Future.cancel(true)
                                     // so we will ignore the stacktrace
                                 }
                             }
-    
+
                             counter.incrementAndGet();
                             inner.schedule(this, 10, TimeUnit.MILLISECONDS);
                         }
                     }, 10, TimeUnit.MILLISECONDS);
                 }
             });
-    
+
             latch.await();
             inner.unsubscribe();
             unsubscribeLatch.countDown();
@@ -238,9 +238,9 @@ public void recursionFromOuterActionAndUnsubscribeInside() throws InterruptedExc
         final Worker inner = getScheduler().createWorker();
         try {
             inner.schedule(new Action0() {
-    
+
                 int i = 0;
-    
+
                 @Override
                 public void call() {
                     i++;
@@ -254,7 +254,7 @@ public void call() {
                     }
                 }
             });
-    
+
             latch.await();
         } finally {
             inner.unsubscribe();
@@ -267,9 +267,9 @@ public void testRecursion() throws InterruptedException {
         final Worker inner = getScheduler().createWorker();
         try {
             inner.schedule(new Action0() {
-    
+
                 private long i = 0;
-    
+
                 @Override
                 public void call() {
                     i++;
@@ -283,7 +283,7 @@ public void call() {
                     }
                 }
             });
-    
+
             latch.await();
         } finally {
             inner.unsubscribe();
@@ -305,26 +305,26 @@ public void call(final Subscriber<? super Integer> observer) {
                         public void call() {
                             observer.onNext(42);
                             latch.countDown();
-    
+
                             // this will recursively schedule this task for execution again
                             inner.schedule(this);
                         }
                     });
-    
+
                     observer.add(Subscriptions.create(new Action0() {
-    
+
                         @Override
                         public void call() {
                             inner.unsubscribe();
                             observer.onCompleted();
                             completionLatch.countDown();
                         }
-    
+
                     }));
-    
+
                 }
             });
-    
+
             final AtomicInteger count = new AtomicInteger();
             final AtomicBoolean completed = new AtomicBoolean(false);
             Subscription subscribe = obs.subscribe(new Subscriber<Integer>() {
@@ -333,31 +333,31 @@ public void onCompleted() {
                     System.out.println("Completed");
                     completed.set(true);
                 }
-    
+
                 @Override
                 public void onError(Throwable e) {
                     System.out.println("Error");
                 }
-    
+
                 @Override
                 public void onNext(Integer args) {
                     count.incrementAndGet();
                     System.out.println(args);
                 }
             });
-    
+
             if (!latch.await(5000, TimeUnit.MILLISECONDS)) {
                 fail("Timed out waiting on onNext latch");
             }
-    
+
             // now unsubscribe and ensure it stops the recursive loop
             subscribe.unsubscribe();
             System.out.println("unsubscribe");
-    
+
             if (!completionLatch.await(5000, TimeUnit.MILLISECONDS)) {
                 fail("Timed out waiting on completion latch");
             }
-    
+
             // the count can be 10 or higher due to thread scheduling of the unsubscribe vs the scheduler looping to emit the count
             assertTrue(count.get() >= 10);
             assertTrue(completed.get());
diff --git a/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index e1252e7214..c0502a6fe0 100644
--- a/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -49,16 +49,16 @@ public void testNestedActions() throws InterruptedException {
         final Scheduler.Worker inner = scheduler.createWorker();
         try {
             final CountDownLatch latch = new CountDownLatch(1);
-    
+
             final Action0 firstStepStart = mock(Action0.class);
             final Action0 firstStepEnd = mock(Action0.class);
-    
+
             final Action0 secondStepStart = mock(Action0.class);
             final Action0 secondStepEnd = mock(Action0.class);
-    
+
             final Action0 thirdStepStart = mock(Action0.class);
             final Action0 thirdStepEnd = mock(Action0.class);
-    
+
             final Action0 firstAction = new Action0() {
                 @Override
                 public void call() {
@@ -73,7 +73,7 @@ public void call() {
                     secondStepStart.call();
                     inner.schedule(firstAction);
                     secondStepEnd.call();
-    
+
                 }
             };
             final Action0 thirdAction = new Action0() {
@@ -84,13 +84,13 @@ public void call() {
                     thirdStepEnd.call();
                 }
             };
-    
+
             InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd);
-    
+
             inner.schedule(thirdAction);
-    
+
             latch.await();
-    
+
             inOrder.verify(thirdStepStart, times(1)).call();
             inOrder.verify(thirdStepEnd, times(1)).call();
             inOrder.verify(secondStepStart, times(1)).call();
@@ -135,7 +135,7 @@ public String call(String s) {
 
     /**
      * The order of execution is nondeterministic.
-     * 
+     *
      * @throws InterruptedException
      */
     @SuppressWarnings("rawtypes")
@@ -147,10 +147,10 @@ public final void testSequenceOfActions() throws InterruptedException {
             final CountDownLatch latch = new CountDownLatch(2);
             final Action0 first = mock(Action0.class);
             final Action0 second = mock(Action0.class);
-    
+
             // make it wait until both the first and second are called
             doAnswer(new Answer() {
-    
+
                 @Override
                 public Object answer(InvocationOnMock invocation) throws Throwable {
                     try {
@@ -161,7 +161,7 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
                 }
             }).when(first).call();
             doAnswer(new Answer() {
-    
+
                 @Override
                 public Object answer(InvocationOnMock invocation) throws Throwable {
                     try {
@@ -171,12 +171,12 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
                     }
                 }
             }).when(second).call();
-    
+
             inner.schedule(first);
             inner.schedule(second);
-    
+
             latch.await();
-    
+
             verify(first, times(1)).call();
             verify(second, times(1)).call();
         } finally {
@@ -188,19 +188,19 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
     public void testSequenceOfDelayedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();
         final Scheduler.Worker inner = scheduler.createWorker();
-        
+
         try {
             final CountDownLatch latch = new CountDownLatch(1);
             final Action0 first = mock(Action0.class);
             final Action0 second = mock(Action0.class);
-    
+
             inner.schedule(new Action0() {
                 @Override
                 public void call() {
                     inner.schedule(first, 30, TimeUnit.MILLISECONDS);
                     inner.schedule(second, 10, TimeUnit.MILLISECONDS);
                     inner.schedule(new Action0() {
-    
+
                         @Override
                         public void call() {
                             latch.countDown();
@@ -208,10 +208,10 @@ public void call() {
                     }, 40, TimeUnit.MILLISECONDS);
                 }
             });
-    
+
             latch.await();
             InOrder inOrder = inOrder(first, second);
-    
+
             inOrder.verify(second, times(1)).call();
             inOrder.verify(first, times(1)).call();
         } finally {
@@ -223,14 +223,14 @@ public void call() {
     public void testMixOfDelayedAndNonDelayedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();
         final Scheduler.Worker inner = scheduler.createWorker();
-        
+
         try {
             final CountDownLatch latch = new CountDownLatch(1);
             final Action0 first = mock(Action0.class);
             final Action0 second = mock(Action0.class);
             final Action0 third = mock(Action0.class);
             final Action0 fourth = mock(Action0.class);
-    
+
             inner.schedule(new Action0() {
                 @Override
                 public void call() {
@@ -239,7 +239,7 @@ public void call() {
                     inner.schedule(third, 100, TimeUnit.MILLISECONDS);
                     inner.schedule(fourth);
                     inner.schedule(new Action0() {
-    
+
                         @Override
                         public void call() {
                             latch.countDown();
@@ -247,10 +247,10 @@ public void call() {
                     }, 400, TimeUnit.MILLISECONDS);
                 }
             });
-    
+
             latch.await();
             InOrder inOrder = inOrder(first, second, third, fourth);
-    
+
             inOrder.verify(first, times(1)).call();
             inOrder.verify(fourth, times(1)).call();
             inOrder.verify(third, times(1)).call();
@@ -264,13 +264,13 @@ public void call() {
     public final void testRecursiveExecution() throws InterruptedException {
         final Scheduler scheduler = getScheduler();
         final Scheduler.Worker inner = scheduler.createWorker();
-        
+
         try {
-            
+
             final AtomicInteger i = new AtomicInteger();
             final CountDownLatch latch = new CountDownLatch(1);
             inner.schedule(new Action0() {
-    
+
                 @Override
                 public void call() {
                     if (i.incrementAndGet() < 100) {
@@ -280,7 +280,7 @@ public void call() {
                     }
                 }
             });
-    
+
             latch.await();
             assertEquals(100, i.get());
         } finally {
@@ -292,15 +292,15 @@ public void call() {
     public final void testRecursiveExecutionWithDelayTime() throws InterruptedException {
         Scheduler scheduler = getScheduler();
         final Scheduler.Worker inner = scheduler.createWorker();
-        
+
         try {
             final AtomicInteger i = new AtomicInteger();
             final CountDownLatch latch = new CountDownLatch(1);
-    
+
             inner.schedule(new Action0() {
-    
+
                 int state = 0;
-    
+
                 @Override
                 public void call() {
                     i.set(state);
@@ -310,9 +310,9 @@ public void call() {
                         latch.countDown();
                     }
                 }
-    
+
             });
-    
+
             latch.await();
             assertEquals(100, i.get());
         } finally {
@@ -450,7 +450,7 @@ public void call(Subscriber<? super String> observer) {
 
     /**
      * Used to determine if onNext is being invoked concurrently.
-     * 
+     *
      * @param <T>
      */
     private static class ConcurrentObserverValidator<T> extends Subscriber<T> {
@@ -490,16 +490,16 @@ public void onNext(T args) {
         }
 
     }
-    
+
     @Test
     public void periodicTaskCancelsItself() throws Exception {
         Scheduler scheduler = getScheduler();
-        if (scheduler instanceof rx.internal.schedulers.ImmediateScheduler 
+        if (scheduler instanceof rx.internal.schedulers.ImmediateScheduler
                 || scheduler instanceof rx.internal.schedulers.TrampolineScheduler) {
             return;
         }
         Worker w = scheduler.createWorker();
-        
+
         try {
             final CountDownLatch cdl = new CountDownLatch(1);
             final int[] executions = { 0 };
@@ -509,21 +509,21 @@ public void periodicTaskCancelsItself() throws Exception {
                 public void call() {
                     executions[0]++;
                     while (cancel.get() == null);
-                    
+
                     cancel.get().unsubscribe();
                     cdl.countDown();
                 }
             }, 100, 100, TimeUnit.MILLISECONDS);
-            
+
             cancel.set(s);
-            
+
             if (!cdl.await(5, TimeUnit.SECONDS)) {
                 s.unsubscribe();
                 Assert.fail("The await timed out");
             }
-            
+
             Assert.assertEquals(1, executions[0]);
-            
+
         } finally {
             w.unsubscribe();
         }
diff --git a/src/test/java/rx/schedulers/ComputationSchedulerTests.java b/src/test/java/rx/schedulers/ComputationSchedulerTests.java
index 2988fab822..0841d815a9 100644
--- a/src/test/java/rx/schedulers/ComputationSchedulerTests.java
+++ b/src/test/java/rx/schedulers/ComputationSchedulerTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -47,13 +47,13 @@ public void testThreadSafetyWhenSchedulerIsHoppingBetweenThreads() {
         final HashMap<String, Integer> map = new HashMap<String, Integer>();
 
         final Scheduler.Worker inner = Schedulers.computation().createWorker();
-        
+
         try {
             inner.schedule(new Action0() {
-    
+
                 private HashMap<String, Integer> statefulMap = map;
                 int nonThreadSafeCounter = 0;
-    
+
                 @Override
                 public void call() {
                     Integer i = statefulMap.get("a");
@@ -75,17 +75,17 @@ public void call() {
                     }
                 }
             });
-    
+
             try {
                 latch.await();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
-    
+
             System.out.println("Count A: " + map.get("a"));
             System.out.println("Count B: " + map.get("b"));
             System.out.println("nonThreadSafeCounter: " + map.get("nonThreadSafeCounter"));
-    
+
             assertEquals(NUM, map.get("a").intValue());
             assertEquals(NUM, map.get("b").intValue());
             assertEquals(NUM, map.get("nonThreadSafeCounter").intValue());
@@ -152,7 +152,7 @@ public final void testUnhandledErrorIsDeliveredToThreadHandler() throws Interrup
     public final void testHandledErrorIsNotDeliveredToThreadHandler() throws InterruptedException {
         SchedulerTests.testHandledErrorIsNotDeliveredToThreadHandler(getScheduler());
     }
-    
+
     @Test(timeout = 60000)
     public void testCancelledTaskRetention() throws InterruptedException {
         Worker w = Schedulers.computation().createWorker();
diff --git a/src/test/java/rx/schedulers/DeprecatedSchedulersTest.java b/src/test/java/rx/schedulers/DeprecatedSchedulersTest.java
index b6ac98c67d..288be2f2de 100644
--- a/src/test/java/rx/schedulers/DeprecatedSchedulersTest.java
+++ b/src/test/java/rx/schedulers/DeprecatedSchedulersTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -46,14 +46,14 @@ void checkWorker(Class<?> schedulerClass) {
         if (UnsafeAccess.isUnsafeAvailable()) {
             try {
                 Scheduler s =  (Scheduler)UnsafeAccess.UNSAFE.allocateInstance(schedulerClass);
-                
+
                 assertNull(s.createWorker());
             } catch (InstantiationException e) {
                 throw new IllegalStateException(e);
             }
         }
     }
-    
+
     @Test
     public void immediateWorker() {
         checkWorker(ImmediateScheduler.class);
@@ -63,7 +63,7 @@ public void immediateWorker() {
     public void newThreadWorker() {
         checkWorker(NewThreadScheduler.class);
     }
-    
+
     @Test
     public void trampolineWorker() {
         checkWorker(TrampolineScheduler.class);
diff --git a/src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java b/src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java
index 93303ce87d..4091cb52bf 100644
--- a/src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java
+++ b/src/test/java/rx/schedulers/GenericScheduledExecutorServiceTest.java
@@ -30,24 +30,24 @@ public class GenericScheduledExecutorServiceTest {
     public void genericScheduledExecutorServiceHook() {
         // make sure the class is initialized
         Assert.assertNotNull(GenericScheduledExecutorService.class);
-        
+
         final ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
         try {
-            
+
             RxJavaHooks.setOnGenericScheduledExecutorService(new Func0<ScheduledExecutorService>() {
                 @Override
                 public ScheduledExecutorService call() {
                     return exec;
                 }
             });
-            
+
             Schedulers.shutdown();
             Schedulers.start();
-            
+
             Assert.assertSame(exec, GenericScheduledExecutorService.getInstance());
-            
+
             RxJavaHooks.setOnGenericScheduledExecutorService(null);
-            
+
             Schedulers.shutdown();
             // start() is package private so had to move this test here
             Schedulers.start();
@@ -58,6 +58,6 @@ public ScheduledExecutorService call() {
             RxJavaHooks.reset();
             exec.shutdownNow();
         }
-        
+
     }
 }
diff --git a/src/test/java/rx/schedulers/ImmediateSchedulerTest.java b/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
index c68e4843b5..cd3bca91b1 100644
--- a/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
+++ b/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/schedulers/IoSchedulerTest.java b/src/test/java/rx/schedulers/IoSchedulerTest.java
index 2db6d5c7b6..b52b133968 100644
--- a/src/test/java/rx/schedulers/IoSchedulerTest.java
+++ b/src/test/java/rx/schedulers/IoSchedulerTest.java
@@ -68,7 +68,7 @@ public final void testUnhandledErrorIsDeliveredToThreadHandler() throws Interrup
     public final void testHandledErrorIsNotDeliveredToThreadHandler() throws InterruptedException {
         SchedulerTests.testHandledErrorIsNotDeliveredToThreadHandler(getScheduler());
     }
-    
+
     @Test(timeout = 60000)
     public void testCancelledTaskRetention() throws InterruptedException {
         Worker w = Schedulers.io().createWorker();
diff --git a/src/test/java/rx/schedulers/NewThreadSchedulerTest.java b/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
index 48fa0d9887..57344cbf67 100644
--- a/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
+++ b/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -53,7 +53,7 @@ public void testNoSelfInterrupt() throws InterruptedException {
             final CountDownLatch done = new CountDownLatch(1);
             final AtomicReference<Throwable> exception = new AtomicReference<Throwable>();
             final AtomicBoolean interruptFlag = new AtomicBoolean();
-            
+
             ScheduledAction sa = (ScheduledAction)worker.schedule(new Action0() {
                 @Override
                 public void call() {
@@ -64,7 +64,7 @@ public void call() {
                     }
                 }
             });
-            
+
             sa.add(Subscriptions.create(new Action0() {
                 @Override
                 public void call() {
@@ -72,11 +72,11 @@ public void call() {
                     done.countDown();
                 }
             }));
-            
+
             run.countDown();
-            
+
             done.await();
-            
+
             Assert.assertEquals(null, exception.get());
             Assert.assertFalse("Interrupted?!", interruptFlag.get());
         } finally {
diff --git a/src/test/java/rx/schedulers/ResetSchedulersTest.java b/src/test/java/rx/schedulers/ResetSchedulersTest.java
index fc06c6c5f5..001743b019 100644
--- a/src/test/java/rx/schedulers/ResetSchedulersTest.java
+++ b/src/test/java/rx/schedulers/ResetSchedulersTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/schedulers/SchedulerLifecycleTest.java b/src/test/java/rx/schedulers/SchedulerLifecycleTest.java
index 49887f9e0d..14a7bab06e 100644
--- a/src/test/java/rx/schedulers/SchedulerLifecycleTest.java
+++ b/src/test/java/rx/schedulers/SchedulerLifecycleTest.java
@@ -34,10 +34,10 @@ public class SchedulerLifecycleTest {
     @Test
     public void testShutdown() throws InterruptedException {
         tryOutSchedulers();
-        
+
         System.out.println("testShutdown >> Giving time threads to spin-up");
         Thread.sleep(500);
-        
+
         Set<Thread> rxThreads = new HashSet<Thread>();
         for (Thread t : Thread.getAllStackTraces().keySet()) {
             if (t.getName().startsWith("Rx")) {
@@ -47,7 +47,7 @@ public void testShutdown() throws InterruptedException {
         Schedulers.shutdown();
         System.out.println("testShutdown >> Giving time to threads to stop");
         Thread.sleep(500);
-        
+
         StringBuilder b = new StringBuilder();
         for (Thread t : rxThreads) {
             if (t.isAlive()) {
@@ -63,47 +63,47 @@ public void testShutdown() throws InterruptedException {
             Schedulers.start(); // restart them anyways
             fail("Rx Threads were still alive:\r\n" + b);
         }
-        
+
         System.out.println("testShutdown >> Restarting schedulers...");
         Schedulers.start();
-        
+
         tryOutSchedulers();
     }
 
     private void tryOutSchedulers() throws InterruptedException {
         final CountDownLatch cdl = new CountDownLatch(4);
-        
+
         final Action0 countAction = new Action0() {
             @Override
             public void call() {
                 cdl.countDown();
             }
         };
-        
+
         CompositeSubscription csub = new CompositeSubscription();
-        
+
         try {
             Worker w1 = Schedulers.computation().createWorker();
             csub.add(w1);
             w1.schedule(countAction);
-            
+
             Worker w2 = Schedulers.io().createWorker();
             csub.add(w2);
             w2.schedule(countAction);
-            
+
             Worker w3 = Schedulers.newThread().createWorker();
             csub.add(w3);
             w3.schedule(countAction);
-            
+
             GenericScheduledExecutorService.getInstance().execute(new Runnable() {
                 @Override
                 public void run() {
                     countAction.call();
                 }
             });
-            
+
             RxRingBuffer.getSpscInstance().release();
-            
+
             if (!cdl.await(3, TimeUnit.SECONDS)) {
                 fail("countAction was not run by every worker");
             }
@@ -111,14 +111,14 @@ public void run() {
             csub.unsubscribe();
         }
     }
-    
+
     @Test
     public void testStartIdempotence() throws InterruptedException {
         tryOutSchedulers();
-        
+
         System.out.println("testStartIdempotence >> giving some time");
         Thread.sleep(500);
-        
+
         Set<Thread> rxThreads = new HashSet<Thread>();
         for (Thread t : Thread.getAllStackTraces().keySet()) {
             if (t.getName().startsWith("Rx")) {
@@ -130,7 +130,7 @@ public void testStartIdempotence() throws InterruptedException {
         Schedulers.start();
         System.out.println("testStartIdempotence >> giving some time again");
         Thread.sleep(500);
-        
+
         Set<Thread> rxThreads2 = new HashSet<Thread>();
         for (Thread t : Thread.getAllStackTraces().keySet()) {
             if (t.getName().startsWith("Rx")) {
@@ -138,7 +138,7 @@ public void testStartIdempotence() throws InterruptedException {
                 System.out.println("testStartIdempotence >>>> " + t);
             }
         }
-        
+
         assertEquals(rxThreads, rxThreads2);
     }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/schedulers/SchedulerTests.java b/src/test/java/rx/schedulers/SchedulerTests.java
index bc929d1bef..c216580284 100644
--- a/src/test/java/rx/schedulers/SchedulerTests.java
+++ b/src/test/java/rx/schedulers/SchedulerTests.java
@@ -44,7 +44,7 @@ private SchedulerTests() {
      * <p>
      * Schedulers which execute on a separate thread from their calling thread should exhibit this behavior. Schedulers
      * which execute on their calling thread may not.
-     * 
+     *
      * @param scheduler the scheduler to test
      * @throws InterruptedException if some wait is interrupted
      */
diff --git a/src/test/java/rx/schedulers/SchedulerWhenTest.java b/src/test/java/rx/schedulers/SchedulerWhenTest.java
index c6c3386d04..49ff840e65 100644
--- a/src/test/java/rx/schedulers/SchedulerWhenTest.java
+++ b/src/test/java/rx/schedulers/SchedulerWhenTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -50,7 +50,7 @@ public void testAsyncMaxConcurrent() {
 		tSched.advanceTimeBy(1, SECONDS);
 		tSub.assertValueCount(5);
 		tSub.assertCompleted();
-		
+
 		sched.unsubscribe();
 	}
 
@@ -94,7 +94,7 @@ public void testAsyncDelaySubscription() {
 		tSched.advanceTimeBy(1, SECONDS);
 		tSub.assertValueCount(5);
 		tSub.assertCompleted();
-		
+
 		sched.unsubscribe();
 	}
 
@@ -112,7 +112,7 @@ public void testSyncMaxConcurrent() {
 		// since all the work is synchronous nothing is blocked and its all done
 		tSub.assertValueCount(5);
 		tSub.assertCompleted();
-		
+
 		sched.unsubscribe();
 	}
 
@@ -141,7 +141,7 @@ public void testSyncDelaySubscription() {
 		tSched.advanceTimeBy(1, SECONDS);
 		tSub.assertValueCount(5);
 		tSub.assertCompleted();
-		
+
 		sched.unsubscribe();
 	}
 
diff --git a/src/test/java/rx/schedulers/TestSchedulerTest.java b/src/test/java/rx/schedulers/TestSchedulerTest.java
index f8a49eb0be..ba95fd1df9 100644
--- a/src/test/java/rx/schedulers/TestSchedulerTest.java
+++ b/src/test/java/rx/schedulers/TestSchedulerTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -47,7 +47,7 @@ public final void testPeriodicScheduling() {
 
         final TestScheduler scheduler = new TestScheduler();
         final Scheduler.Worker inner = scheduler.createWorker();
-        
+
         try {
             inner.schedulePeriodically(new Action0() {
                 @Override
@@ -56,27 +56,27 @@ public void call() {
                     calledOp.call(scheduler.now());
                 }
             }, 1, 2, TimeUnit.SECONDS);
-    
+
             verify(calledOp, never()).call(anyLong());
-    
+
             InOrder inOrder = Mockito.inOrder(calledOp);
-    
+
             scheduler.advanceTimeBy(999L, TimeUnit.MILLISECONDS);
             inOrder.verify(calledOp, never()).call(anyLong());
-    
+
             scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
             inOrder.verify(calledOp, times(1)).call(1000L);
-    
+
             scheduler.advanceTimeBy(1999L, TimeUnit.MILLISECONDS);
             inOrder.verify(calledOp, never()).call(3000L);
-    
+
             scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
             inOrder.verify(calledOp, times(1)).call(3000L);
-    
+
             scheduler.advanceTimeBy(5L, TimeUnit.SECONDS);
             inOrder.verify(calledOp, times(1)).call(5000L);
             inOrder.verify(calledOp, times(1)).call(7000L);
-    
+
             inner.unsubscribe();
             scheduler.advanceTimeBy(11L, TimeUnit.SECONDS);
             inOrder.verify(calledOp, never()).call(anyLong());
@@ -102,27 +102,27 @@ public void call() {
                     calledOp.call(scheduler.now());
                 }
             }, 1, 2, TimeUnit.SECONDS);
-    
+
             verify(calledOp, never()).call(anyLong());
-    
+
             InOrder inOrder = Mockito.inOrder(calledOp);
-    
+
             scheduler.advanceTimeBy(999L, TimeUnit.MILLISECONDS);
             inOrder.verify(calledOp, never()).call(anyLong());
-    
+
             scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
             inOrder.verify(calledOp, times(1)).call(1000L);
-    
+
             scheduler.advanceTimeBy(1999L, TimeUnit.MILLISECONDS);
             inOrder.verify(calledOp, never()).call(3000L);
-    
+
             scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
             inOrder.verify(calledOp, times(1)).call(3000L);
-    
+
             scheduler.advanceTimeBy(5L, TimeUnit.SECONDS);
             inOrder.verify(calledOp, times(1)).call(5000L);
             inOrder.verify(calledOp, times(1)).call(7000L);
-    
+
             subscription.unsubscribe();
             scheduler.advanceTimeBy(11L, TimeUnit.SECONDS);
             inOrder.verify(calledOp, never()).call(anyLong());
@@ -136,17 +136,17 @@ public final void testImmediateUnsubscribes() {
         TestScheduler s = new TestScheduler();
         final Scheduler.Worker inner = s.createWorker();
         final AtomicInteger counter = new AtomicInteger(0);
-        
+
         try {
             inner.schedule(new Action0() {
-    
+
                 @Override
                 public void call() {
                     counter.incrementAndGet();
                     System.out.println("counter: " + counter.get());
                     inner.schedule(this);
                 }
-    
+
             });
             inner.unsubscribe();
             assertEquals(0, counter.get());
@@ -161,16 +161,16 @@ public final void testImmediateUnsubscribes2() {
         final Scheduler.Worker inner = s.createWorker();
         try {
             final AtomicInteger counter = new AtomicInteger(0);
-    
+
             final Subscription subscription = inner.schedule(new Action0() {
-    
+
                 @Override
                 public void call() {
                     counter.incrementAndGet();
                     System.out.println("counter: " + counter.get());
                     inner.schedule(this);
                 }
-    
+
             });
             subscription.unsubscribe();
             assertEquals(0, counter.get());
@@ -183,10 +183,10 @@ public void call() {
     public final void testNestedSchedule() {
         final TestScheduler scheduler = new TestScheduler();
         final Scheduler.Worker inner = scheduler.createWorker();
-        
+
         try {
             final Action0 calledOp = mock(Action0.class);
-    
+
             Observable<Object> poller;
             poller = Observable.create(new OnSubscribe<Object>() {
                 @Override
@@ -202,19 +202,19 @@ public void call() {
                     });
                 }
             });
-    
+
             InOrder inOrder = Mockito.inOrder(calledOp);
-    
+
             Subscription sub;
             sub = poller.subscribe();
-    
+
             scheduler.advanceTimeTo(6, TimeUnit.SECONDS);
             inOrder.verify(calledOp, times(2)).call();
-    
+
             sub.unsubscribe();
             scheduler.advanceTimeTo(11, TimeUnit.SECONDS);
             inOrder.verify(calledOp, never()).call();
-    
+
             sub = poller.subscribe();
             scheduler.advanceTimeTo(12, TimeUnit.SECONDS);
             inOrder.verify(calledOp, times(1)).call();
diff --git a/src/test/java/rx/schedulers/TimeXTest.java b/src/test/java/rx/schedulers/TimeXTest.java
index d0fde5287f..c236e5fda4 100644
--- a/src/test/java/rx/schedulers/TimeXTest.java
+++ b/src/test/java/rx/schedulers/TimeXTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Netflix, Inc.
- * 
+ *
  * 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.
@@ -32,32 +32,32 @@ public void timestamped() {
         Timestamped<Integer> ts7 = new Timestamped<Integer>(1L, new Integer(1)); // have unique reference
         Timestamped<Integer> ts8 = new Timestamped<Integer>(1L, 3);
         Timestamped<Integer> ts9 = new Timestamped<Integer>(1L, null);
-        
+
         assertEquals(1L, ts1.getTimestampMillis());
         assertEquals(1, ts1.getValue().intValue());
-        
+
         assertNotEquals(ts1, null);
         assertNotEquals(ts1, "string");
-        
+
         assertEquals(ts1, ts1);
         assertEquals(ts1, ts2);
         assertEquals(ts1, ts7);
         assertEquals(ts7, ts1);
-        
+
         assertNotEquals(ts1, ts3);
         assertNotEquals(ts1, ts4);
         assertNotEquals(ts1, ts8);
         assertNotEquals(ts8, ts1);
         assertNotEquals(ts1, ts9);
         assertNotEquals(ts9, ts1);
-        
+
         assertNotEquals(ts1, ts5);
         assertNotEquals(ts5, ts1);
-        
+
         assertEquals(ts5, ts6);
-        
+
         assertEquals("Timestamped(timestampMillis = 1, value = 1)", ts1.toString());
-        
+
         assertEquals(ts1.hashCode(), ts2.hashCode());
 
         assertEquals(ts5.hashCode(), ts6.hashCode());
@@ -74,32 +74,32 @@ public void timeInterval() {
         TimeInterval<Integer> ts7 = new TimeInterval<Integer>(1L, new Integer(1)); // have unique reference
         TimeInterval<Integer> ts8 = new TimeInterval<Integer>(1L, 3);
         TimeInterval<Integer> ts9 = new TimeInterval<Integer>(1L, null);
-        
+
         assertEquals(1L, ts1.getIntervalInMilliseconds());
         assertEquals(1, ts1.getValue().intValue());
-        
+
         assertNotEquals(ts1, null);
         assertNotEquals(ts1, "string");
-        
+
         assertEquals(ts1, ts1);
         assertEquals(ts1, ts2);
         assertEquals(ts1, ts7);
         assertEquals(ts7, ts1);
-        
+
         assertNotEquals(ts1, ts3);
         assertNotEquals(ts1, ts4);
         assertNotEquals(ts1, ts8);
         assertNotEquals(ts8, ts1);
         assertNotEquals(ts1, ts9);
         assertNotEquals(ts9, ts1);
-        
+
         assertNotEquals(ts1, ts5);
         assertNotEquals(ts5, ts1);
-        
+
         assertEquals(ts5, ts6);
-        
+
         assertEquals("TimeInterval [intervalInMilliseconds=1, value=1]", ts1.toString());
-        
+
         assertEquals(ts1.hashCode(), ts2.hashCode());
 
         assertEquals(ts5.hashCode(), ts6.hashCode());
diff --git a/src/test/java/rx/schedulers/TrampolineSchedulerTest.java b/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
index aad14239a5..f191fa9819 100644
--- a/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
+++ b/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -71,27 +71,27 @@ public void testNestedTrampolineWithUnsubscribe() {
         try {
             workers.add(worker);
             worker.schedule(new Action0() {
-    
+
                 @Override
                 public void call() {
                     workers.add(doWorkOnNewTrampoline("A", workDone));
                 }
-    
+
             });
-    
+
             final Worker worker2 = Schedulers.trampoline().createWorker();
             workers.add(worker2);
             worker2.schedule(new Action0() {
-    
+
                 @Override
                 public void call() {
                     workers.add(doWorkOnNewTrampoline("B", workDone));
                     // we unsubscribe worker2 ... it should not affect work scheduled on a separate Trampoline.Worker
                     worker2.unsubscribe();
                 }
-    
+
             });
-        
+
             assertEquals(6, workDone.size());
             assertEquals(Arrays.asList("A.1", "A.B.1", "A.B.2", "B.1", "B.B.1", "B.B.2"), workDone);
         } finally {
diff --git a/src/test/java/rx/subjects/AsyncSubjectTest.java b/src/test/java/rx/subjects/AsyncSubjectTest.java
index 82f6843f90..0f2b2c1dbe 100644
--- a/src/test/java/rx/subjects/AsyncSubjectTest.java
+++ b/src/test/java/rx/subjects/AsyncSubjectTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -204,7 +204,7 @@ public void testSubscribeCompletionRaceCondition() {
         /*
          * With non-threadsafe code this fails most of the time on my dev laptop and is non-deterministic enough
          * to act as a unit test to the race conditions.
-         * 
+         *
          * With the synchronization code in place I can not get this to fail on my laptop.
          */
         for (int i = 0; i < 50; i++) {
@@ -276,7 +276,7 @@ public SubjectObserverThread(AsyncSubject<String> subject) {
         @Override
         public void run() {
             try {
-                // a timeout exception will happen if we don't get a terminal state 
+                // a timeout exception will happen if we don't get a terminal state
                 String v = subject.timeout(2000, TimeUnit.MILLISECONDS).toBlocking().single();
                 value.set(v);
             } catch (Exception e) {
@@ -284,7 +284,7 @@ public void run() {
             }
         }
     }
-    
+
     @Test
     public void testOnErrorThrowsDoesntPreventDelivery() {
         AsyncSubject<String> ps = AsyncSubject.create();
@@ -299,10 +299,10 @@ public void testOnErrorThrowsDoesntPreventDelivery() {
         } catch (OnErrorNotImplementedException e) {
             // ignore
         }
-        // even though the onError above throws we should still receive it on the other subscriber 
+        // even though the onError above throws we should still receive it on the other subscriber
         assertEquals(1, ts.getOnErrorEvents().size());
     }
-    
+
     /**
      * This one has multiple failures so should get a CompositeException
      */
@@ -325,28 +325,28 @@ public void testOnErrorThrowsDoesntPreventDelivery2() {
             // we should have 5 of them
             assertEquals(5, e.getExceptions().size());
         }
-        // even though the onError above throws we should still receive it on the other subscriber 
+        // even though the onError above throws we should still receive it on the other subscriber
         assertEquals(1, ts.getOnErrorEvents().size());
     }
 
     @Test
     public void testCurrentStateMethodsNormal() {
         AsyncSubject<Object> as = AsyncSubject.create();
-        
+
         assertFalse(as.hasValue());
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getValue());
         assertNull(as.getThrowable());
-        
+
         as.onNext(1);
-        
+
         assertTrue(as.hasValue());
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertEquals(1, as.getValue());
         assertNull(as.getThrowable());
-        
+
         as.onCompleted();
         assertTrue(as.hasValue());
         assertFalse(as.hasThrowable());
@@ -354,19 +354,19 @@ public void testCurrentStateMethodsNormal() {
         assertEquals(1, as.getValue());
         assertNull(as.getThrowable());
     }
-    
+
     @Test
     public void testCurrentStateMethodsEmpty() {
         AsyncSubject<Object> as = AsyncSubject.create();
-        
+
         assertFalse(as.hasValue());
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getValue());
         assertNull(as.getThrowable());
-        
+
         as.onCompleted();
-        
+
         assertFalse(as.hasValue());
         assertFalse(as.hasThrowable());
         assertTrue(as.hasCompleted());
@@ -376,28 +376,28 @@ public void testCurrentStateMethodsEmpty() {
     @Test
     public void testCurrentStateMethodsError() {
         AsyncSubject<Object> as = AsyncSubject.create();
-        
+
         assertFalse(as.hasValue());
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getValue());
         assertNull(as.getThrowable());
-        
+
         as.onError(new TestException());
-        
+
         assertFalse(as.hasValue());
         assertTrue(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getValue());
         assertTrue(as.getThrowable() instanceof TestException);
     }
-    
+
     @Test
     public void testAsyncSubjectValueRelay() {
         AsyncSubject<Integer> async = AsyncSubject.create();
         async.onNext(1);
         async.onCompleted();
-        
+
         assertFalse(async.hasObservers());
         assertTrue(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -409,7 +409,7 @@ public void testAsyncSubjectValueRelay() {
     public void testAsyncSubjectValueEmpty() {
         AsyncSubject<Integer> async = AsyncSubject.create();
         async.onCompleted();
-        
+
         assertFalse(async.hasObservers());
         assertTrue(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -422,7 +422,7 @@ public void testAsyncSubjectValueError() {
         AsyncSubject<Integer> async = AsyncSubject.create();
         TestException te = new TestException();
         async.onError(te);
-        
+
         assertFalse(async.hasObservers());
         assertFalse(async.hasCompleted());
         assertTrue(async.hasThrowable());
@@ -430,45 +430,45 @@ public void testAsyncSubjectValueError() {
         assertNull(async.getValue());
         assertFalse(async.hasValue());
     }
-    
+
     @Test
     public void backpressureOnline() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         AsyncSubject<Integer> subject = AsyncSubject.create();
-        
+
         subject.subscribe(ts);
-        
+
         subject.onNext(1);
         subject.onCompleted();
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
         ts.assertCompleted();
         ts.assertNoErrors();
     }
-    
+
     @Test
     public void backpressureOffline() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         AsyncSubject<Integer> subject = AsyncSubject.create();
         subject.onNext(1);
         subject.onCompleted();
-        
+
         subject.subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValue(1);
         ts.assertCompleted();
         ts.assertNoErrors();
diff --git a/src/test/java/rx/subjects/BehaviorSubjectTest.java b/src/test/java/rx/subjects/BehaviorSubjectTest.java
index 5b201814d5..1c06ff73a1 100644
--- a/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -243,7 +243,7 @@ public void testCompletedAfterErrorIsNotSent3() {
     @Test(timeout = 5000)
     public void testUnsubscriptionCase() {
         BehaviorSubject<String> src = BehaviorSubject.create((String)null);
-        
+
         for (int i = 0; i < 10; i++) {
             @SuppressWarnings("unchecked")
             final Observer<Object> o = mock(Observer.class);
@@ -272,25 +272,25 @@ public void testStartEmpty() {
         @SuppressWarnings("unchecked")
         final Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
-        
+
         source.subscribe(o);
-        
+
         inOrder.verify(o, never()).onNext(any());
         inOrder.verify(o, never()).onCompleted();
-        
+
         source.onNext(1);
-        
+
         source.onCompleted();
-        
+
         source.onNext(2);
-        
+
         verify(o, never()).onError(any(Throwable.class));
 
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
-        
-        
+
+
     }
     @Test
     public void testStartEmptyThenAddOne() {
@@ -311,9 +311,9 @@ public void testStartEmptyThenAddOne() {
 
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
-        
+
         verify(o, never()).onError(any(Throwable.class));
-        
+
     }
     @Test
     public void testStartEmptyCompleteWithOne() {
@@ -331,15 +331,15 @@ public void testStartEmptyCompleteWithOne() {
         verify(o).onCompleted();
         verifyNoMoreInteractions(o);
     }
-    
+
     @Test
     public void testTakeOneSubscriber() {
         BehaviorSubject<Integer> source = BehaviorSubject.create(1);
         @SuppressWarnings("unchecked")
         final Observer<Object> o = mock(Observer.class);
-        
+
         source.take(1).subscribe(o);
-        
+
         verify(o).onNext(1);
         verify(o).onCompleted();
         verifyNoMoreInteractions(o);
@@ -347,7 +347,7 @@ public void testTakeOneSubscriber() {
         assertEquals(0, source.subscriberCount());
         assertFalse(source.hasObservers());
     }
-    
+
     @Test
     public void testOnErrorThrowsDoesntPreventDelivery() {
         BehaviorSubject<String> ps = BehaviorSubject.create();
@@ -362,10 +362,10 @@ public void testOnErrorThrowsDoesntPreventDelivery() {
         } catch (OnErrorNotImplementedException e) {
             // ignore
         }
-        // even though the onError above throws we should still receive it on the other subscriber 
+        // even though the onError above throws we should still receive it on the other subscriber
         assertEquals(1, ts.getOnErrorEvents().size());
     }
-    
+
     /**
      * This one has multiple failures so should get a CompositeException
      */
@@ -388,7 +388,7 @@ public void testOnErrorThrowsDoesntPreventDelivery2() {
             // we should have 5 of them
             assertEquals(5, e.getExceptions().size());
         }
-        // even though the onError above throws we should still receive it on the other subscriber 
+        // even though the onError above throws we should still receive it on the other subscriber
         assertEquals(1, ts.getOnErrorEvents().size());
     }
     @Test
@@ -401,10 +401,10 @@ public void testEmissionSubscriptionRace() throws Exception {
                     System.out.println(i);
                 }
                 final BehaviorSubject<Object> rs = BehaviorSubject.create();
-                
-                final CountDownLatch finish = new CountDownLatch(1); 
-                final CountDownLatch start = new CountDownLatch(1); 
-                
+
+                final CountDownLatch finish = new CountDownLatch(1);
+                final CountDownLatch start = new CountDownLatch(1);
+
                 worker.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -416,33 +416,33 @@ public void call() {
                         rs.onNext(1);
                     }
                 });
-                
+
                 final AtomicReference<Object> o = new AtomicReference<Object>();
-                
+
                 rs.subscribeOn(s).observeOn(Schedulers.io())
                 .subscribe(new Observer<Object>() {
-    
+
                     @Override
                     public void onCompleted() {
                         o.set(-1);
                         finish.countDown();
                     }
-    
+
                     @Override
                     public void onError(Throwable e) {
                         o.set(e);
                         finish.countDown();
                     }
-    
+
                     @Override
                     public void onNext(Object t) {
                         o.set(t);
                         finish.countDown();
                     }
-                    
+
                 });
                 start.countDown();
-                
+
                 if (!finish.await(5, TimeUnit.SECONDS)) {
                     System.out.println(o.get());
                     System.out.println(rs.hasObservers());
@@ -463,52 +463,52 @@ public void call() {
             worker.unsubscribe();
         }
     }
-    
+
     @Test
     public void testCurrentStateMethodsNormalEmptyStart() {
         BehaviorSubject<Object> as = BehaviorSubject.create();
-        
+
         assertFalse(as.hasValue());
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getValue());
         assertNull(as.getThrowable());
-        
+
         as.onNext(1);
-        
+
         assertTrue(as.hasValue());
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertEquals(1, as.getValue());
         assertNull(as.getThrowable());
-        
+
         as.onCompleted();
-        
+
         assertFalse(as.hasValue());
         assertFalse(as.hasThrowable());
         assertTrue(as.hasCompleted());
         assertNull(as.getValue());
         assertNull(as.getThrowable());
     }
-    
+
     @Test
     public void testCurrentStateMethodsNormalSomeStart() {
         BehaviorSubject<Object> as = BehaviorSubject.create((Object)1);
-        
+
         assertTrue(as.hasValue());
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertEquals(1, as.getValue());
         assertNull(as.getThrowable());
-        
+
         as.onNext(2);
-        
+
         assertTrue(as.hasValue());
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertEquals(2, as.getValue());
         assertNull(as.getThrowable());
-        
+
         as.onCompleted();
         assertFalse(as.hasValue());
         assertFalse(as.hasThrowable());
@@ -516,19 +516,19 @@ public void testCurrentStateMethodsNormalSomeStart() {
         assertNull(as.getValue());
         assertNull(as.getThrowable());
     }
-    
+
     @Test
     public void testCurrentStateMethodsEmpty() {
         BehaviorSubject<Object> as = BehaviorSubject.create();
-        
+
         assertFalse(as.hasValue());
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getValue());
         assertNull(as.getThrowable());
-        
+
         as.onCompleted();
-        
+
         assertFalse(as.hasValue());
         assertFalse(as.hasThrowable());
         assertTrue(as.hasCompleted());
@@ -538,28 +538,28 @@ public void testCurrentStateMethodsEmpty() {
     @Test
     public void testCurrentStateMethodsError() {
         BehaviorSubject<Object> as = BehaviorSubject.create();
-        
+
         assertFalse(as.hasValue());
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getValue());
         assertNull(as.getThrowable());
-        
+
         as.onError(new TestException());
-        
+
         assertFalse(as.hasValue());
         assertTrue(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getValue());
         assertTrue(as.getThrowable() instanceof TestException);
     }
-    
+
     @Test
     public void testBehaviorSubjectValueRelay() {
         BehaviorSubject<Integer> async = BehaviorSubject.create();
         async.onNext(1);
         async.onCompleted();
-        
+
         assertFalse(async.hasObservers());
         assertTrue(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -575,7 +575,7 @@ public void testBehaviorSubjectValueRelay() {
     public void testBehaviorSubjectValueRelayIncomplete() {
         BehaviorSubject<Integer> async = BehaviorSubject.create();
         async.onNext(1);
-        
+
         assertFalse(async.hasObservers());
         assertFalse(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -590,7 +590,7 @@ public void testBehaviorSubjectValueRelayIncomplete() {
     @Test
     public void testBehaviorSubjectIncompleteEmpty() {
         BehaviorSubject<Integer> async = BehaviorSubject.create();
-        
+
         assertFalse(async.hasObservers());
         assertFalse(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -606,7 +606,7 @@ public void testBehaviorSubjectIncompleteEmpty() {
     public void testBehaviorSubjectEmpty() {
         BehaviorSubject<Integer> async = BehaviorSubject.create();
         async.onCompleted();
-        
+
         assertFalse(async.hasObservers());
         assertTrue(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -623,7 +623,7 @@ public void testBehaviorSubjectError() {
         BehaviorSubject<Integer> async = BehaviorSubject.create();
         TestException te = new TestException();
         async.onError(te);
-        
+
         assertFalse(async.hasObservers());
         assertFalse(async.hasCompleted());
         assertTrue(async.hasThrowable());
diff --git a/src/test/java/rx/subjects/BufferUntilSubscriberTest.java b/src/test/java/rx/subjects/BufferUntilSubscriberTest.java
index 556254ae9f..d1ad426a96 100644
--- a/src/test/java/rx/subjects/BufferUntilSubscriberTest.java
+++ b/src/test/java/rx/subjects/BufferUntilSubscriberTest.java
@@ -80,39 +80,39 @@ public void call(List<Integer> integers) {
         else
             Assert.assertEquals(NITERS, counter.get());
     }
-    
+
     @Test
     public void testBackpressure() {
         UnicastSubject<Integer> bus = UnicastSubject.create();
         for (int i = 0; i < 32; i++) {
             bus.onNext(i);
         }
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         bus.subscribe(ts);
-        
+
         ts.assertValueCount(0);
         ts.assertNoTerminalEvent();
-        
+
         ts.requestMore(10);
-        
+
         ts.assertValueCount(10);
-        
+
         ts.requestMore(22);
         ts.assertValueCount(32);
 
         Assert.assertFalse(bus.state.caughtUp);
 
         ts.requestMore(Long.MAX_VALUE);
-        
+
         Assert.assertTrue(bus.state.caughtUp);
 
         for (int i = 32; i < 64; i++) {
             bus.onNext(i);
         }
         bus.onCompleted();
-        
+
         ts.assertValueCount(64);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -124,11 +124,11 @@ public void testErrorCutsAhead() {
             bus.onNext(i);
         }
         bus.onError(new TestException());
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         bus.subscribe(ts);
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(TestException.class);
@@ -139,16 +139,16 @@ public void testErrorCutsAheadAfterSubscribed() {
         for (int i = 0; i < 32; i++) {
             bus.onNext(i);
         }
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         bus.subscribe(ts);
 
         ts.assertNoValues();
         ts.assertNoTerminalEvent();
 
         bus.onError(new TestException());
-        
+
         ts.assertNoValues();
         ts.assertNotCompleted();
         ts.assertError(TestException.class);
@@ -159,19 +159,19 @@ public void testUnsubscribeClearsQueue() {
         for (int i = 0; i < 32; i++) {
             bus.onNext(i);
         }
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
         ts.unsubscribe();
-        
+
         bus.subscribe(ts);
-        
+
         ts.assertNoTerminalEvent();
         ts.assertNoValues();
-        
+
         Assert.assertTrue(bus.state.queue.isEmpty());
-        
+
         bus.onNext(32);
-        
+
         Assert.assertTrue(bus.state.queue.isEmpty());
     }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/subjects/PublishSubjectTest.java b/src/test/java/rx/subjects/PublishSubjectTest.java
index e5f4ee647d..2a052abd04 100644
--- a/src/test/java/rx/subjects/PublishSubjectTest.java
+++ b/src/test/java/rx/subjects/PublishSubjectTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -365,14 +365,14 @@ public void onCompleted() {
                     }
                 });
             src.onNext(v);
-            
+
             inOrder.verify(o).onNext(v + ", " + v);
             inOrder.verify(o).onCompleted();
             verify(o, never()).onError(any(Throwable.class));
         }
     }
-    
-    
+
+
     @Test
     public void testOnErrorThrowsDoesntPreventDelivery() {
         PublishSubject<String> ps = PublishSubject.create();
@@ -387,10 +387,10 @@ public void testOnErrorThrowsDoesntPreventDelivery() {
         } catch (OnErrorNotImplementedException e) {
             // ignore
         }
-        // even though the onError above throws we should still receive it on the other subscriber 
+        // even though the onError above throws we should still receive it on the other subscriber
         assertEquals(1, ts.getOnErrorEvents().size());
     }
-    
+
     /**
      * This one has multiple failures so should get a CompositeException
      */
@@ -413,40 +413,40 @@ public void testOnErrorThrowsDoesntPreventDelivery2() {
             // we should have 5 of them
             assertEquals(5, e.getExceptions().size());
         }
-        // even though the onError above throws we should still receive it on the other subscriber 
+        // even though the onError above throws we should still receive it on the other subscriber
         assertEquals(1, ts.getOnErrorEvents().size());
     }
     @Test
     public void testCurrentStateMethodsNormal() {
         PublishSubject<Object> as = PublishSubject.create();
-        
+
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getThrowable());
-        
+
         as.onNext(1);
-        
+
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getThrowable());
-        
+
         as.onCompleted();
-        
+
         assertFalse(as.hasThrowable());
         assertTrue(as.hasCompleted());
         assertNull(as.getThrowable());
     }
-    
+
     @Test
     public void testCurrentStateMethodsEmpty() {
         PublishSubject<Object> as = PublishSubject.create();
-        
+
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getThrowable());
-        
+
         as.onCompleted();
-        
+
         assertFalse(as.hasThrowable());
         assertTrue(as.hasCompleted());
         assertNull(as.getThrowable());
@@ -454,35 +454,35 @@ public void testCurrentStateMethodsEmpty() {
     @Test
     public void testCurrentStateMethodsError() {
         PublishSubject<Object> as = PublishSubject.create();
-        
+
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getThrowable());
-        
+
         as.onError(new TestException());
-        
+
         assertTrue(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertTrue(as.getThrowable() instanceof TestException);
     }
-    
+
     @Test
     public void testPublishSubjectValueRelay() {
         PublishSubject<Integer> async = PublishSubject.create();
         async.onNext(1);
         async.onCompleted();
-        
+
         assertFalse(async.hasObservers());
         assertTrue(async.hasCompleted());
         assertFalse(async.hasThrowable());
         assertNull(async.getThrowable());
     }
-    
+
     @Test
     public void testPublishSubjectValueEmpty() {
         PublishSubject<Integer> async = PublishSubject.create();
         async.onCompleted();
-        
+
         assertFalse(async.hasObservers());
         assertTrue(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -493,36 +493,36 @@ public void testPublishSubjectValueError() {
         PublishSubject<Integer> async = PublishSubject.create();
         TestException te = new TestException();
         async.onError(te);
-        
+
         assertFalse(async.hasObservers());
         assertFalse(async.hasCompleted());
         assertTrue(async.hasThrowable());
         assertSame(te, async.getThrowable());
     }
-    
+
     @Test
     public void backpressureFailFast() {
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         TestSubscriber<Integer> ts = TestSubscriber.create(1);
-        
+
         ps.subscribe(ts);
-        
+
         ps.onNext(1);
-        
+
         ts.assertValue(1);
         ts.assertNoErrors();
         ts.assertNotCompleted();
-        
+
         ps.onNext(2);
-        
+
         ts.assertValue(1);
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
 
         assertEquals("PublishSubject: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
     }
-    
+
     @Test
     public void crossUnsubscribe() {
         PublishSubject<Integer> ps = PublishSubject.create();
@@ -538,23 +538,23 @@ public void onNext(Integer t) {
                 }
             }
         };
-        
+
         ps.subscribe(ts1);
         ps.subscribe(ts0);
-        
+
         ps.onNext(1);
-        
+
         ts0.assertValue(1);
         ts1.assertValue(1);
-        
+
         ps.onNext(2);
         ps.onCompleted();
-        
+
         ts0.assertValue(1);
         ts0.assertNoErrors();
         ts0.assertNotCompleted();
         ts0.assertUnsubscribed();
-        
+
         ts1.assertValues(1, 2);
         ts1.assertNoErrors();
         ts1.assertCompleted();
diff --git a/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java b/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
index fa0b5e5764..72149ee677 100644
--- a/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -161,11 +161,11 @@ public void unboundedReplaySubjectConcurrentSubscriptionsLoop() throws Exception
             unboundedReplaySubjectConcurrentSubscriptions();
         }
     }
-    
+
     @Test
     public void unboundedReplaySubjectConcurrentSubscriptions() throws InterruptedException {
         final ReplaySubject<Long> replay = ReplaySubject.createUnbounded();
-        
+
         ReplaySubjectConcurrencyTest.concurrencyTest(replay);
     }
 
@@ -176,11 +176,11 @@ public void unboundedTimeReplaySubjectConcurrentSubscriptionsLoop() throws Excep
             unboundedTimeReplaySubjectConcurrentSubscriptions();
         }
     }
-    
+
     @Test
     public void unboundedTimeReplaySubjectConcurrentSubscriptions() throws InterruptedException {
         final ReplaySubject<Long> replay = ReplaySubject.createUnboundedTime();
-        
+
         ReplaySubjectConcurrencyTest.concurrencyTest(replay);
     }
 
@@ -245,7 +245,7 @@ public void run() {
         }
 
     }
-    
+
     /**
      * https://github.com/ReactiveX/RxJava/issues/1147
      */
@@ -273,7 +273,7 @@ public SubjectObserverThread(ReplaySubject<String> subject) {
         @Override
         public void run() {
             try {
-                // a timeout exception will happen if we don't get a terminal state 
+                // a timeout exception will happen if we don't get a terminal state
                 String v = subject.timeout(2000, TimeUnit.MILLISECONDS).toBlocking().single();
                 value.set(v);
             } catch (Exception e) {
@@ -291,10 +291,10 @@ public void testReplaySubjectEmissionSubscriptionRace() throws Exception {
                     System.out.println(i);
                 }
                 final ReplaySubject<Object> rs = ReplaySubject.createWithSize(2);
-                
-                final CountDownLatch finish = new CountDownLatch(1); 
-                final CountDownLatch start = new CountDownLatch(1); 
-                
+
+                final CountDownLatch finish = new CountDownLatch(1);
+                final CountDownLatch start = new CountDownLatch(1);
+
                 worker.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -306,33 +306,33 @@ public void call() {
                         rs.onNext(1);
                     }
                 });
-                
+
                 final AtomicReference<Object> o = new AtomicReference<Object>();
-                
+
                 rs.subscribeOn(s).observeOn(Schedulers.io())
                 .subscribe(new Observer<Object>() {
-    
+
                     @Override
                     public void onCompleted() {
                         o.set(-1);
                         finish.countDown();
                     }
-    
+
                     @Override
                     public void onError(Throwable e) {
                         o.set(e);
                         finish.countDown();
                     }
-    
+
                     @Override
                     public void onNext(Object t) {
                         o.set(t);
                         finish.countDown();
                     }
-                    
+
                 });
                 start.countDown();
-                
+
                 if (!finish.await(5, TimeUnit.SECONDS)) {
                     System.out.println(o.get());
                     System.out.println(rs.hasObservers());
@@ -357,7 +357,7 @@ public void call() {
     public void testConcurrentSizeAndHasAnyValue() throws InterruptedException {
         final ReplaySubject<Object> rs = ReplaySubject.createUnbounded();
         final CyclicBarrier cb = new CyclicBarrier(2);
-        
+
         Thread t = new Thread(new Runnable() {
             @Override
             public void run() {
@@ -404,14 +404,14 @@ public void run() {
             }
             lastSize = size;
         }
-        
+
         t.join();
     }
     @Test(timeout = 5000)
     public void testConcurrentSizeAndHasAnyValueBounded() throws InterruptedException {
         final ReplaySubject<Object> rs = ReplaySubject.createWithSize(3);
         final CyclicBarrier cb = new CyclicBarrier(2);
-        
+
         Thread t = new Thread(new Runnable() {
             @Override
             public void run() {
@@ -447,14 +447,14 @@ public void run() {
                 assertEquals(1, v2 - v1);
             }
         }
-        
+
         t.join();
     }
     @Test(timeout = 10000)
     public void testConcurrentSizeAndHasAnyValueTimeBounded() throws InterruptedException {
         final ReplaySubject<Object> rs = ReplaySubject.createWithTime(1, TimeUnit.MILLISECONDS, Schedulers.computation());
         final CyclicBarrier cb = new CyclicBarrier(2);
-        
+
         Thread t = new Thread(new Runnable() {
             @Override
             public void run() {
@@ -497,7 +497,7 @@ public void run() {
                 assertEquals(1, v2 - v1);
             }
         }
-        
+
         t.join();
     }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java b/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
index 97fea6898b..5e1c350462 100644
--- a/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -161,14 +161,14 @@ public void testReplaySubjectConcurrentSubscriptionsLoop() throws Exception {
             testReplaySubjectConcurrentSubscriptions();
         }
     }
-    
+
     @Test
     public void testReplaySubjectConcurrentSubscriptions() throws InterruptedException {
         final ReplaySubject<Long> replay = ReplaySubject.create();
-        
+
         concurrencyTest(replay);
     }
-    
+
     public static void concurrencyTest(final ReplaySubject<Long> replay) throws InterruptedException {
         Thread source = new Thread(new Runnable() {
 
@@ -320,7 +320,7 @@ public void run() {
         }
 
     }
-    
+
     /**
      * https://github.com/ReactiveX/RxJava/issues/1147
      */
@@ -348,7 +348,7 @@ public SubjectObserverThread(ReplaySubject<String> subject) {
         @Override
         public void run() {
             try {
-                // a timeout exception will happen if we don't get a terminal state 
+                // a timeout exception will happen if we don't get a terminal state
                 String v = subject.timeout(2000, TimeUnit.MILLISECONDS).toBlocking().single();
                 value.set(v);
             } catch (Exception e) {
@@ -366,10 +366,10 @@ public void testReplaySubjectEmissionSubscriptionRace() throws Exception {
                     System.out.println(i);
                 }
                 final ReplaySubject<Object> rs = ReplaySubject.create();
-                
-                final CountDownLatch finish = new CountDownLatch(1); 
-                final CountDownLatch start = new CountDownLatch(1); 
-                
+
+                final CountDownLatch finish = new CountDownLatch(1);
+                final CountDownLatch start = new CountDownLatch(1);
+
                 worker.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -381,33 +381,33 @@ public void call() {
                         rs.onNext(1);
                     }
                 });
-                
+
                 final AtomicReference<Object> o = new AtomicReference<Object>();
-                
+
                 rs.subscribeOn(s).observeOn(Schedulers.io())
                 .subscribe(new Observer<Object>() {
-    
+
                     @Override
                     public void onCompleted() {
                         o.set(-1);
                         finish.countDown();
                     }
-    
+
                     @Override
                     public void onError(Throwable e) {
                         o.set(e);
                         finish.countDown();
                     }
-    
+
                     @Override
                     public void onNext(Object t) {
                         o.set(t);
                         finish.countDown();
                     }
-                    
+
                 });
                 start.countDown();
-                
+
                 if (!finish.await(5, TimeUnit.SECONDS)) {
                     System.out.println(o.get());
                     System.out.println(rs.hasObservers());
@@ -422,7 +422,7 @@ public void call() {
                             rs.onCompleted();
                         }
                     });
-                    
+
                 }
             }
         } finally {
@@ -433,7 +433,7 @@ public void call() {
     public void testConcurrentSizeAndHasAnyValue() throws InterruptedException {
         final ReplaySubject<Object> rs = ReplaySubject.create();
         final CyclicBarrier cb = new CyclicBarrier(2);
-        
+
         Thread t = new Thread(new Runnable() {
             @Override
             public void run() {
@@ -475,7 +475,7 @@ public void run() {
             }
             lastSize = size;
         }
-        
+
         t.join();
     }
 }
diff --git a/src/test/java/rx/subjects/ReplaySubjectTest.java b/src/test/java/rx/subjects/ReplaySubjectTest.java
index de2db7846b..8464cf1b3f 100644
--- a/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -334,23 +334,23 @@ public void onNext(String v) {
         System.out.println("after waiting for one");
 
         subject.onNext("three");
-        
+
         System.out.println("sent three");
-        
-        // if subscription blocked existing subscribers then 'makeSlow' would cause this to not be there yet 
+
+        // if subscription blocked existing subscribers then 'makeSlow' would cause this to not be there yet
         assertEquals("three", lastValueForObserver1.get());
-        
+
         System.out.println("about to send onCompleted");
-        
+
         subject.onCompleted();
 
         System.out.println("completed subject");
-        
-        // release 
+
+        // release
         makeSlow.countDown();
-        
+
         System.out.println("makeSlow released");
-        
+
         completed.await();
         // all of them should be emitted with the last being "three"
         assertEquals("three", lastValueForObserver2.get());
@@ -359,19 +359,19 @@ public void onNext(String v) {
     @Test
     public void testSubscriptionLeak() {
         ReplaySubject<Object> replaySubject = ReplaySubject.create();
-        
+
         Subscription s = replaySubject.subscribe();
 
         assertEquals(1, replaySubject.subscriberCount());
 
         s.unsubscribe();
-        
+
         assertEquals(0, replaySubject.subscriberCount());
     }
     @Test(timeout = 5000)
     public void testUnsubscriptionCase() {
         ReplaySubject<String> src = ReplaySubject.create();
-        
+
         for (int i = 0; i < 10; i++) {
             @SuppressWarnings("unchecked")
             final Observer<Object> o = mock(Observer.class);
@@ -415,10 +415,10 @@ public void testTerminateOnce() {
         source.onNext(1);
         source.onNext(2);
         source.onCompleted();
-        
+
         @SuppressWarnings("unchecked")
         final Observer<Integer> o = mock(Observer.class);
-        
+
         source.unsafeSubscribe(new Subscriber<Integer>() {
 
             @Override
@@ -436,7 +436,7 @@ public void onCompleted() {
                 o.onCompleted();
             }
         });
-        
+
         verify(o).onNext(1);
         verify(o).onNext(2);
         verify(o).onCompleted();
@@ -445,11 +445,11 @@ public void onCompleted() {
     @Test
     public void testReplay1AfterTermination() {
         ReplaySubject<Integer> source = ReplaySubject.createWithSize(1);
-        
+
         source.onNext(1);
         source.onNext(2);
         source.onCompleted();
-        
+
         for (int i = 0; i < 1; i++) {
             @SuppressWarnings("unchecked")
             Observer<Integer> o = mock(Observer.class);
@@ -483,16 +483,16 @@ public void testReplay1Directly() {
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testReplayTimestampedAfterTermination() {
         TestScheduler scheduler = new TestScheduler();
         ReplaySubject<Integer> source = ReplaySubject.createWithTime(1, TimeUnit.SECONDS, scheduler);
-        
+
         source.onNext(1);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         source.onNext(2);
 
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
@@ -506,21 +506,21 @@ public void testReplayTimestampedAfterTermination() {
         Observer<Integer> o = mock(Observer.class);
 
         source.subscribe(o);
-        
+
         verify(o, never()).onNext(1);
         verify(o, never()).onNext(2);
         verify(o, never()).onNext(3); // late subscribers no longer replay stale data
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
-    
+
     @Test
     public void testReplayTimestampedDirectly() {
         TestScheduler scheduler = new TestScheduler();
         ReplaySubject<Integer> source = ReplaySubject.createWithTime(1, TimeUnit.SECONDS, scheduler);
 
         source.onNext(1);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
         @SuppressWarnings("unchecked")
@@ -529,24 +529,24 @@ public void testReplayTimestampedDirectly() {
         source.subscribe(o);
 
         source.onNext(2);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         source.onNext(3);
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         source.onCompleted();
-        
+
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
-        
+
         verify(o, never()).onError(any(Throwable.class));
         verify(o, never()).onNext(1);
         verify(o).onNext(2);
         verify(o).onNext(3);
         verify(o).onCompleted();
     }
-    
+
     @Test
     public void testOnErrorThrowsDoesntPreventDelivery() {
         ReplaySubject<String> ps = ReplaySubject.create();
@@ -561,10 +561,10 @@ public void testOnErrorThrowsDoesntPreventDelivery() {
         } catch (OnErrorNotImplementedException e) {
             // ignore
         }
-        // even though the onError above throws we should still receive it on the other subscriber 
+        // even though the onError above throws we should still receive it on the other subscriber
         assertEquals(1, ts.getOnErrorEvents().size());
     }
-    
+
     /**
      * This one has multiple failures so should get a CompositeException
      */
@@ -587,41 +587,41 @@ public void testOnErrorThrowsDoesntPreventDelivery2() {
             // we should have 5 of them
             assertEquals(5, e.getExceptions().size());
         }
-        // even though the onError above throws we should still receive it on the other subscriber 
+        // even though the onError above throws we should still receive it on the other subscriber
         assertEquals(1, ts.getOnErrorEvents().size());
     }
-    
+
     @Test
     public void testCurrentStateMethodsNormal() {
         ReplaySubject<Object> as = ReplaySubject.create();
-        
+
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getThrowable());
-        
+
         as.onNext(1);
-        
+
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getThrowable());
-        
+
         as.onCompleted();
-        
+
         assertFalse(as.hasThrowable());
         assertTrue(as.hasCompleted());
         assertNull(as.getThrowable());
     }
-    
+
     @Test
     public void testCurrentStateMethodsEmpty() {
         ReplaySubject<Object> as = ReplaySubject.create();
-        
+
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getThrowable());
-        
+
         as.onCompleted();
-        
+
         assertFalse(as.hasThrowable());
         assertTrue(as.hasCompleted());
         assertNull(as.getThrowable());
@@ -629,13 +629,13 @@ public void testCurrentStateMethodsEmpty() {
     @Test
     public void testCurrentStateMethodsError() {
         ReplaySubject<Object> as = ReplaySubject.create();
-        
+
         assertFalse(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertNull(as.getThrowable());
-        
+
         as.onError(new TestException());
-        
+
         assertTrue(as.hasThrowable());
         assertFalse(as.hasCompleted());
         assertTrue(as.getThrowable() instanceof TestException);
@@ -643,20 +643,20 @@ public void testCurrentStateMethodsError() {
     @Test
     public void testSizeAndHasAnyValueUnbounded() {
         ReplaySubject<Object> rs = ReplaySubject.create();
-        
+
         assertEquals(0, rs.size());
         assertFalse(rs.hasAnyValue());
-        
+
         rs.onNext(1);
-        
+
         assertEquals(1, rs.size());
         assertTrue(rs.hasAnyValue());
-        
+
         rs.onNext(1);
 
         assertEquals(2, rs.size());
         assertTrue(rs.hasAnyValue());
-        
+
         rs.onCompleted();
 
         assertEquals(2, rs.size());
@@ -665,43 +665,43 @@ public void testSizeAndHasAnyValueUnbounded() {
     @Test
     public void testSizeAndHasAnyValueEffectivelyUnbounded() {
         ReplaySubject<Object> rs = ReplaySubject.createUnbounded();
-        
+
         assertEquals(0, rs.size());
         assertFalse(rs.hasAnyValue());
-        
+
         rs.onNext(1);
-        
+
         assertEquals(1, rs.size());
         assertTrue(rs.hasAnyValue());
-        
+
         rs.onNext(1);
 
         assertEquals(2, rs.size());
         assertTrue(rs.hasAnyValue());
-        
+
         rs.onCompleted();
 
         assertEquals(2, rs.size());
         assertTrue(rs.hasAnyValue());
     }
-    
+
     @Test
     public void testSizeAndHasAnyValueUnboundedError() {
         ReplaySubject<Object> rs = ReplaySubject.create();
-        
+
         assertEquals(0, rs.size());
         assertFalse(rs.hasAnyValue());
-        
+
         rs.onNext(1);
-        
+
         assertEquals(1, rs.size());
         assertTrue(rs.hasAnyValue());
-        
+
         rs.onNext(1);
 
         assertEquals(2, rs.size());
         assertTrue(rs.hasAnyValue());
-        
+
         rs.onError(new TestException());
 
         assertEquals(2, rs.size());
@@ -710,30 +710,30 @@ public void testSizeAndHasAnyValueUnboundedError() {
     @Test
     public void testSizeAndHasAnyValueEffectivelyUnboundedError() {
         ReplaySubject<Object> rs = ReplaySubject.createUnbounded();
-        
+
         assertEquals(0, rs.size());
         assertFalse(rs.hasAnyValue());
-        
+
         rs.onNext(1);
-        
+
         assertEquals(1, rs.size());
         assertTrue(rs.hasAnyValue());
-        
+
         rs.onNext(1);
 
         assertEquals(2, rs.size());
         assertTrue(rs.hasAnyValue());
-        
+
         rs.onError(new TestException());
 
         assertEquals(2, rs.size());
         assertTrue(rs.hasAnyValue());
     }
-    
+
     @Test
     public void testSizeAndHasAnyValueUnboundedEmptyError() {
         ReplaySubject<Object> rs = ReplaySubject.create();
-        
+
         rs.onError(new TestException());
 
         assertEquals(0, rs.size());
@@ -742,17 +742,17 @@ public void testSizeAndHasAnyValueUnboundedEmptyError() {
     @Test
     public void testSizeAndHasAnyValueEffectivelyUnboundedEmptyError() {
         ReplaySubject<Object> rs = ReplaySubject.createUnbounded();
-        
+
         rs.onError(new TestException());
 
         assertEquals(0, rs.size());
         assertFalse(rs.hasAnyValue());
     }
-    
+
     @Test
     public void testSizeAndHasAnyValueUnboundedEmptyCompleted() {
         ReplaySubject<Object> rs = ReplaySubject.create();
-        
+
         rs.onCompleted();
 
         assertEquals(0, rs.size());
@@ -761,41 +761,41 @@ public void testSizeAndHasAnyValueUnboundedEmptyCompleted() {
     @Test
     public void testSizeAndHasAnyValueEffectivelyUnboundedEmptyCompleted() {
         ReplaySubject<Object> rs = ReplaySubject.createUnbounded();
-        
+
         rs.onCompleted();
 
         assertEquals(0, rs.size());
         assertFalse(rs.hasAnyValue());
     }
-    
+
     @Test
     public void testSizeAndHasAnyValueSizeBounded() {
         ReplaySubject<Object> rs = ReplaySubject.createWithSize(1);
-        
+
         assertEquals(0, rs.size());
         assertFalse(rs.hasAnyValue());
-        
+
         for (int i = 0; i < 1000; i++) {
             rs.onNext(i);
 
             assertEquals(1, rs.size());
             assertTrue(rs.hasAnyValue());
         }
-        
+
         rs.onCompleted();
 
         assertEquals(1, rs.size());
         assertTrue(rs.hasAnyValue());
     }
-    
+
     @Test
     public void testSizeAndHasAnyValueTimeBounded() {
         TestScheduler ts = new TestScheduler();
         ReplaySubject<Object> rs = ReplaySubject.createWithTime(1, TimeUnit.SECONDS, ts);
-        
+
         assertEquals(0, rs.size());
         assertFalse(rs.hasAnyValue());
-        
+
         for (int i = 0; i < 1000; i++) {
             rs.onNext(i);
             ts.advanceTimeBy(500, TimeUnit.MILLISECONDS);
@@ -805,7 +805,7 @@ public void testSizeAndHasAnyValueTimeBounded() {
             assertEquals(0, rs.size()); // stale data no longer peekable
             assertFalse(rs.hasAnyValue());
         }
-        
+
         rs.onCompleted();
 
         assertEquals(0, rs.size());
@@ -821,9 +821,9 @@ public void testGetValues() {
             assertArrayEquals(Arrays.copyOf(expected, i + 1), rs.getValues());
         }
         rs.onCompleted();
-        
+
         assertArrayEquals(expected, rs.getValues());
-        
+
     }
     @Test
     public void testGetValuesUnbounded() {
@@ -835,17 +835,17 @@ public void testGetValuesUnbounded() {
             assertArrayEquals(Arrays.copyOf(expected, i + 1), rs.getValues());
         }
         rs.onCompleted();
-        
+
         assertArrayEquals(expected, rs.getValues());
-        
+
     }
-    
+
     @Test
     public void testReplaySubjectValueRelay() {
         ReplaySubject<Integer> async = ReplaySubject.create();
         async.onNext(1);
         async.onCompleted();
-        
+
         assertFalse(async.hasObservers());
         assertTrue(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -861,7 +861,7 @@ public void testReplaySubjectValueRelay() {
     public void testReplaySubjectValueRelayIncomplete() {
         ReplaySubject<Integer> async = ReplaySubject.create();
         async.onNext(1);
-        
+
         assertFalse(async.hasObservers());
         assertFalse(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -879,7 +879,7 @@ public void testReplaySubjectValueRelayBounded() {
         async.onNext(0);
         async.onNext(1);
         async.onCompleted();
-        
+
         assertFalse(async.hasObservers());
         assertTrue(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -896,7 +896,7 @@ public void testReplaySubjectValueRelayBoundedIncomplete() {
         ReplaySubject<Integer> async = ReplaySubject.createWithSize(1);
         async.onNext(0);
         async.onNext(1);
-        
+
         assertFalse(async.hasObservers());
         assertFalse(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -911,7 +911,7 @@ public void testReplaySubjectValueRelayBoundedIncomplete() {
     @Test
     public void testReplaySubjectValueRelayBoundedEmptyIncomplete() {
         ReplaySubject<Integer> async = ReplaySubject.createWithSize(1);
-        
+
         assertFalse(async.hasObservers());
         assertFalse(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -926,7 +926,7 @@ public void testReplaySubjectValueRelayBoundedEmptyIncomplete() {
     @Test
     public void testReplaySubjectValueRelayEmptyIncomplete() {
         ReplaySubject<Integer> async = ReplaySubject.create();
-        
+
         assertFalse(async.hasObservers());
         assertFalse(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -938,12 +938,12 @@ public void testReplaySubjectValueRelayEmptyIncomplete() {
         assertArrayEquals(new Integer[] { null }, async.getValues(new Integer[] { 0 }));
         assertArrayEquals(new Integer[] { null, 0 }, async.getValues(new Integer[] { 0, 0 }));
     }
-    
+
     @Test
     public void testReplaySubjectEmpty() {
         ReplaySubject<Integer> async = ReplaySubject.create();
         async.onCompleted();
-        
+
         assertFalse(async.hasObservers());
         assertTrue(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -960,7 +960,7 @@ public void testReplaySubjectError() {
         ReplaySubject<Integer> async = ReplaySubject.create();
         TestException te = new TestException();
         async.onError(te);
-        
+
         assertFalse(async.hasObservers());
         assertFalse(async.hasCompleted());
         assertTrue(async.hasThrowable());
@@ -972,12 +972,12 @@ public void testReplaySubjectError() {
         assertArrayEquals(new Integer[] { null }, async.getValues(new Integer[] { 0 }));
         assertArrayEquals(new Integer[] { null, 0 }, async.getValues(new Integer[] { 0, 0 }));
     }
-    
+
     @Test
     public void testReplaySubjectBoundedEmpty() {
         ReplaySubject<Integer> async = ReplaySubject.createWithSize(1);
         async.onCompleted();
-        
+
         assertFalse(async.hasObservers());
         assertTrue(async.hasCompleted());
         assertFalse(async.hasThrowable());
@@ -994,7 +994,7 @@ public void testReplaySubjectBoundedError() {
         ReplaySubject<Integer> async = ReplaySubject.createWithSize(1);
         TestException te = new TestException();
         async.onError(te);
-        
+
         assertFalse(async.hasObservers());
         assertFalse(async.hasCompleted());
         assertTrue(async.hasThrowable());
@@ -1006,38 +1006,38 @@ public void testReplaySubjectBoundedError() {
         assertArrayEquals(new Integer[] { null }, async.getValues(new Integer[] { 0 }));
         assertArrayEquals(new Integer[] { null, 0 }, async.getValues(new Integer[] { 0, 0 }));
     }
-    
+
     void backpressureLive(ReplaySubject<Integer> rs) {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         rs.subscribe(ts);
-        
+
         for (int i = 1; i <= 5; i++) {
             rs.onNext(i);
         }
-        
+
         ts.assertNoValues();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2);
-        
+
         ts.requestMore(6);
 
         ts.assertValues(1, 2, 3, 4, 5);
-        
+
         for (int i = 6; i <= 10; i++) {
             rs.onNext(i);
         }
 
         ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8);
-        
+
         rs.onCompleted();
-        
+
         ts.assertNotCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -1045,7 +1045,7 @@ void backpressureLive(ReplaySubject<Integer> rs) {
 
     void backpressureOffline(ReplaySubject<Integer> rs) {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         for (int i = 1; i <= 10; i++) {
             rs.onNext(i);
         }
@@ -1054,19 +1054,19 @@ void backpressureOffline(ReplaySubject<Integer> rs) {
         rs.subscribe(ts);
 
         ts.assertNoValues();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2);
-        
+
         ts.requestMore(6);
-        
+
         ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8);
-        
+
         ts.assertNotCompleted();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -1074,7 +1074,7 @@ void backpressureOffline(ReplaySubject<Integer> rs) {
 
     void backpressureOffline5(ReplaySubject<Integer> rs) {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        
+
         for (int i = 1; i <= 10; i++) {
             rs.onNext(i);
         }
@@ -1083,19 +1083,19 @@ void backpressureOffline5(ReplaySubject<Integer> rs) {
         rs.subscribe(ts);
 
         ts.assertNoValues();
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(6, 7);
-        
+
         ts.requestMore(2);
-        
+
         ts.assertValues(6, 7, 8, 9);
-        
+
         ts.assertNotCompleted();
-        
+
         ts.requestMore(1);
-        
+
         ts.assertValues(6, 7, 8, 9, 10);
         ts.assertNoErrors();
         ts.assertCompleted();
@@ -1140,37 +1140,37 @@ public void backpressureSizeAndTimeOffline() {
         backpressureOffline(ReplaySubject.<Integer>createWithTimeAndSize(1, TimeUnit.DAYS, 10, Schedulers.immediate()));
         backpressureOffline(ReplaySubject.<Integer>createWithTimeAndSize(1, TimeUnit.DAYS, 100, Schedulers.immediate()));
     }
-    
+
     @Test
     public void filtered() {
         ReplaySubject<Integer> subject = ReplaySubject.create();
-        
+
         TestSubscriber<Integer> ts1 = TestSubscriber.create();
         TestSubscriber<Integer> ts2 = TestSubscriber.create();
-        
+
         Observable<Integer> o = subject.filter(new Func1<Integer, Boolean>() {
             @Override
             public Boolean call(Integer v) {
                 return v > 0;
             }
         });
-        
+
         o.subscribe(ts1);
         o.subscribe(ts2);
-        
+
         subject.onNext(1);
         subject.onNext(2);
         subject.onNext(0);
         subject.onNext(3);
         subject.onNext(0);
         subject.onNext(6);
-        
+
         ts1.assertValues(1, 2, 3, 6);
         ts2.assertValues(1, 2, 3, 6);
-        
+
         subject.onNext(0);
         subject.onNext(7);
-        
+
         ts1.assertValues(1, 2, 3, 6, 7);
         ts2.assertValues(1, 2, 3, 6, 7);
     }
diff --git a/src/test/java/rx/subjects/SerializedSubjectTest.java b/src/test/java/rx/subjects/SerializedSubjectTest.java
index b31a458ffd..d0ced60d23 100644
--- a/src/test/java/rx/subjects/SerializedSubjectTest.java
+++ b/src/test/java/rx/subjects/SerializedSubjectTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -35,7 +35,7 @@ public void testBasic() {
         ts.awaitTerminalEvent();
         ts.assertReceivedOnNext(Arrays.asList("hello"));
     }
-    
+
     @Test
     public void testDontWrapSerializedSubjectAgain() {
         PublishSubject<Object> s = PublishSubject.create();
diff --git a/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java b/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
index 4d3ebd753f..5c8165358e 100644
--- a/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
+++ b/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -401,9 +401,9 @@ public void testAddAllConcurrent() throws InterruptedException {
         final CountDownLatch start = new CountDownLatch(1);
         final CountDownLatch end = new CountDownLatch(10);
         final List<Thread> threads = new ArrayList<Thread>();
-        
+
         final Queue<Throwable> errorQueue = new ConcurrentLinkedQueue<Throwable>();
-        
+
         for (int i = 0; i < count; i++) {
             final Thread t = new Thread() {
                 @Override
@@ -416,7 +416,7 @@ public void run() {
                                 public void unsubscribe() {
                                     counter.incrementAndGet();
                                 }
-    
+
                                 @Override
                                 public boolean isUnsubscribed() {
                                     return false;
@@ -426,7 +426,7 @@ public boolean isUnsubscribed() {
                                 public void unsubscribe() {
                                     counter.incrementAndGet();
                                 }
-    
+
                                 @Override
                                 public boolean isUnsubscribed() {
                                     return false;
@@ -436,7 +436,7 @@ public boolean isUnsubscribed() {
                                 public void unsubscribe() {
                                     counter.incrementAndGet();
                                 }
-    
+
                                 @Override
                                 public boolean isUnsubscribed() {
                                     return false;
@@ -462,7 +462,7 @@ public boolean isUnsubscribed() {
         }
 
         assertEquals(30, counter.get());
-        
+
         assertEquals(errorQueue.toString(), 0, errorQueue.size());
     }
 
diff --git a/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java b/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
index 2db843a420..3f926b6f72 100644
--- a/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
+++ b/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java b/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
index ce62f29e96..51d533db1e 100644
--- a/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
+++ b/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/subscriptions/SerialSubscriptionTests.java b/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
index 8e1d37fe2d..ae51ae1280 100644
--- a/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
+++ b/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/subscriptions/SubscriptionsTest.java b/src/test/java/rx/subscriptions/SubscriptionsTest.java
index 83f47446a0..f1b52b7cb2 100644
--- a/src/test/java/rx/subscriptions/SubscriptionsTest.java
+++ b/src/test/java/rx/subscriptions/SubscriptionsTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
diff --git a/src/test/java/rx/test/OperatorTester.java b/src/test/java/rx/test/OperatorTester.java
index ad03ad1969..12a5433cd0 100644
--- a/src/test/java/rx/test/OperatorTester.java
+++ b/src/test/java/rx/test/OperatorTester.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -23,9 +23,9 @@
 public final class OperatorTester {
     /*
      * This is purposefully package-only so it does not leak into the public API outside of this package.
-     * 
+     *
      * This package is implementation details and not part of the Javadocs and thus can change without breaking backwards compatibility.
-     * 
+     *
      * benjchristensen => I'm procrastinating the decision of where and how these types of classes (see rx.subjects.UnsubscribeTester) should exist.
      * If they are only for internal implementations then I don't want them as part of the API.
      * If they are truly useful for everyone to use then an "rx.testing" package may make sense.
@@ -36,7 +36,7 @@ private OperatorTester() {
 
     /**
      * Used for mocking of Schedulers since many Scheduler implementations are static/final.
-     * 
+     *
      * @param underlying the actual scheduler
      * @return the wrapping Scheduler instance
      */
diff --git a/src/test/java/rx/test/TestObstructionDetection.java b/src/test/java/rx/test/TestObstructionDetection.java
index d24c6721ab..3f9d81cc10 100644
--- a/src/test/java/rx/test/TestObstructionDetection.java
+++ b/src/test/java/rx/test/TestObstructionDetection.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -49,7 +49,7 @@ private TestObstructionDetection() {
      */
     public static void checkObstruction() {
         final int ncpu = Runtime.getRuntime().availableProcessors();
-        
+
         final CountDownLatch cdl = new CountDownLatch(ncpu);
         final List<Scheduler.Worker> workers = new ArrayList<Scheduler.Worker>();
         final Action0 task = new Action0() {
@@ -58,7 +58,7 @@ public void call() {
                 cdl.countDown();
             }
         };
-        
+
         for (int i = 0; i < ncpu; i++) {
             workers.add(Schedulers.computation().createWorker());
         }
diff --git a/src/test/java/rx/test/TestObstructionDetectionTest.java b/src/test/java/rx/test/TestObstructionDetectionTest.java
index f6db1db597..1af4070ed0 100644
--- a/src/test/java/rx/test/TestObstructionDetectionTest.java
+++ b/src/test/java/rx/test/TestObstructionDetectionTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -39,7 +39,7 @@ public static void afterClass() {
     @Test(timeout = 10000, expected = ObstructionException.class)
     public void testObstruction() {
         Scheduler.Worker w = Schedulers.computation().createWorker();
-        
+
         try {
             w.schedule(new Action0() {
                 @Override
@@ -47,7 +47,7 @@ public void call() {
                     try {
                         Thread.sleep(5000);
                     } catch (InterruptedException ex) {
-                        
+
                     }
                 }
             });
@@ -59,14 +59,14 @@ public void call() {
     @Test(timeout = 10000)
     public void testNoObstruction() {
         w = Schedulers.computation().createWorker();
-        
+
         w.schedule(new Action0() {
             @Override
             public void call() {
                 try {
                     Thread.sleep(500);
                 } catch (InterruptedException ex) {
-                    
+
                 }
             }
         });
diff --git a/src/test/java/rx/util/AssertObservable.java b/src/test/java/rx/util/AssertObservable.java
index 728ea1bfb3..41ddaaad1e 100644
--- a/src/test/java/rx/util/AssertObservable.java
+++ b/src/test/java/rx/util/AssertObservable.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.
@@ -42,7 +42,7 @@ public static <T> void assertObservableEqualsBlocking(Observable<T> expected, Ob
      * Asserts that two Observables are equal. If they are not, an {@link AssertionError} is thrown
      * with the given message. If <code>expected</code> and <code>actual</code> are
      * <code>null</code>, they are considered equal.
-     * 
+     *
      * @param <T> the value tpye
      * @param message
      *            the identifying message for the {@link AssertionError} (<code>null</code> okay)
@@ -59,7 +59,7 @@ public static <T> void assertObservableEqualsBlocking(String message, Observable
      * Asserts that two {@link Observable}s are equal and returns an empty {@link Observable}. If
      * they are not, an {@link Observable} is returned that calls onError with an {@link AssertionError} when subscribed to. If <code>expected</code> and <code>actual</code>
      * are <code>null</code>, they are considered equal.
-     * 
+     *
      * @param <T> the value tpye
      * @param expected
      *            Observable with expected values.
diff --git a/src/test/java/rx/util/AssertObservableTest.java b/src/test/java/rx/util/AssertObservableTest.java
index 187735a332..14fdf2468a 100644
--- a/src/test/java/rx/util/AssertObservableTest.java
+++ b/src/test/java/rx/util/AssertObservableTest.java
@@ -1,12 +1,12 @@
 /**
  * Copyright 2014 Netflix, Inc.
- * 
+ *
  * 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.

From 4ae4a40a2f493978851035e18a6159380f15573f Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 15 Sep 2016 09:04:27 +0200
Subject: [PATCH 169/263] 1.2 preparation cleanup and
 Experimental/Beta/Deprecated adjustments (#4549)

---
 src/main/java/rx/AsyncEmitter.java            |   6 +-
 src/main/java/rx/BackpressureOverflow.java    |   8 +-
 src/main/java/rx/Completable.java             | 213 +--------------
 src/main/java/rx/Notification.java            |  11 +-
 src/main/java/rx/Observable.java              | 190 +++++--------
 src/main/java/rx/Scheduler.java               |  22 +-
 src/main/java/rx/Single.java                  |  88 +++---
 src/main/java/rx/SingleSubscriber.java        |   4 +-
 src/main/java/rx/Subscriber.java              |   2 +-
 src/main/java/rx/Subscription.java            |   2 +-
 src/main/java/rx/annotations/Beta.java        |   2 +-
 .../rx/exceptions/CompositeException.java     |  36 +--
 src/main/java/rx/exceptions/Exceptions.java   |  10 +-
 .../java/rx/exceptions/OnErrorThrowable.java  |   4 +-
 .../internal/operators/BackpressureUtils.java |  27 --
 .../operators/BlockingOperatorLatest.java     |  30 +--
 .../operators/BlockingOperatorNext.java       |   9 +-
 .../internal/operators/CachedObservable.java  |  10 +-
 .../rx/internal/operators/OnSubscribeAmb.java |  15 +-
 .../operators/OnSubscribeFlattenIterable.java |  15 +-
 .../operators/OnSubscribeFromIterable.java    |   8 +-
 .../operators/OnSubscribeOnAssembly.java      |   4 +-
 .../OnSubscribeOnAssemblyCompletable.java     |   1 -
 .../internal/operators/OnSubscribeRange.java  |  10 +-
 .../internal/operators/OnSubscribeToMap.java  |   2 +-
 .../OperatorBufferWithSingleObservable.java   |  12 +-
 .../OperatorBufferWithStartEndObservable.java |  12 +-
 .../operators/OperatorBufferWithTime.java     |  22 +-
 .../OperatorDebounceWithSelector.java         |   6 +-
 .../operators/OperatorDebounceWithTime.java   |   6 +-
 .../internal/operators/OperatorGroupBy.java   |   2 +-
 .../rx/internal/operators/OperatorMerge.java  |  13 +-
 .../internal/operators/OperatorMulticast.java |   2 +-
 .../operators/OperatorOnBackpressureDrop.java |   1 -
 .../OperatorOnErrorResumeNextViaFunction.java |   8 +-
 .../internal/operators/OperatorPublish.java   |  67 +++--
 .../rx/internal/operators/OperatorReplay.java |  39 +--
 .../operators/OperatorSequenceEqual.java      |   8 +-
 .../rx/internal/operators/OperatorSingle.java |  24 +-
 .../rx/internal/operators/OperatorSwitch.java |  10 +-
 .../operators/OperatorSwitchIfEmpty.java      |  16 +-
 .../operators/OperatorTakeUntilPredicate.java |   2 +-
 .../OperatorTimeoutWithSelector.java          |   4 +-
 .../OperatorWindowWithObservableFactory.java  |   8 +-
 .../OperatorWindowWithStartEndObservable.java |  24 +-
 .../rx/internal/operators/OperatorZip.java    |   2 +-
 .../SingleOperatorOnErrorResumeNext.java      |   2 +-
 .../producers/SingleDelayedProducer.java      |   4 +-
 .../schedulers/EventLoopsScheduler.java       |   6 +-
 .../schedulers/ExecutorScheduler.java         |   2 +-
 ...enericScheduledExecutorServiceFactory.java |   2 +-
 .../schedulers/ImmediateScheduler.java        |   5 +-
 .../internal/schedulers/NewThreadWorker.java  |   5 +-
 .../schedulers/SchedulerLifecycle.java        |   4 +-
 .../rx/internal/schedulers/SchedulerWhen.java |  12 +-
 .../subscriptions/SequentialSubscription.java |   8 +-
 .../rx/internal/util/IndexedRingBuffer.java   |   6 +-
 .../util/InternalObservableUtils.java         |  18 +-
 .../rx/internal/util/LinkedArrayList.java     |   2 +-
 .../java/rx/internal/util/ObjectPool.java     |   4 +-
 .../java/rx/internal/util/OpenHashSet.java    |   2 +-
 .../java/rx/internal/util/RxRingBuffer.java   |   7 +-
 .../util/ScalarSynchronousObservable.java     |   4 +-
 .../rx/internal/util/SubscriptionList.java    |   2 +-
 .../rx/internal/util/SynchronizedQueue.java   |   5 +-
 .../util/atomic/SpscLinkedArrayQueue.java     |   6 +-
 .../unsafe/ConcurrentCircularArrayQueue.java  |   2 +-
 .../util/unsafe/MessagePassingQueue.java      |   2 +-
 .../internal/util/unsafe/MpmcArrayQueue.java  |   4 +-
 .../internal/util/unsafe/MpscLinkedQueue.java |   2 +-
 .../util/unsafe/SpscUnboundedArrayQueue.java  |   2 +-
 .../rx/observables/BlockingObservable.java    |  23 +-
 .../rx/observables/ConnectableObservable.java |  10 +-
 .../java/rx/observables/SyncOnSubscribe.java  |   8 +-
 .../observers/AsyncCompletableSubscriber.java |   2 +-
 src/main/java/rx/observers/TestObserver.java  |   2 +-
 .../java/rx/plugins/RxJavaErrorHandler.java   |   4 +-
 src/main/java/rx/plugins/RxJavaHooks.java     |  84 +++---
 src/main/java/rx/plugins/RxJavaPlugins.java   |  14 +-
 src/main/java/rx/schedulers/Schedulers.java   |   4 +-
 src/main/java/rx/schedulers/Timestamped.java  |   5 +-
 src/main/java/rx/singles/BlockingSingle.java  |  18 +-
 src/main/java/rx/subjects/AsyncSubject.java   |  11 +-
 .../java/rx/subjects/BehaviorSubject.java     |  17 +-
 src/main/java/rx/subjects/PublishSubject.java |   7 +-
 src/main/java/rx/subjects/ReplaySubject.java  |  30 ++-
 src/main/java/rx/subjects/UnicastSubject.java |  14 +-
 .../subscriptions/CompositeSubscription.java  |   6 +-
 .../java/rx/ObservableConversionTest.java     | 251 ------------------
 src/test/java/rx/ObservableTests.java         |  16 --
 90 files changed, 538 insertions(+), 1123 deletions(-)
 delete mode 100644 src/test/java/rx/ObservableConversionTest.java

diff --git a/src/main/java/rx/AsyncEmitter.java b/src/main/java/rx/AsyncEmitter.java
index 29693b7e90..89b578d3f4 100644
--- a/src/main/java/rx/AsyncEmitter.java
+++ b/src/main/java/rx/AsyncEmitter.java
@@ -25,7 +25,7 @@
  * <p>
  * The onNext, onError and onCompleted methods should be called
  * in a sequential manner, just like the Observer's methods. The
- * other methods are threadsafe.
+ * other methods are thread-safe.
  *
  * @param <T> the value type to emit
  * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
@@ -48,7 +48,7 @@ public interface AsyncEmitter<T> extends Observer<T> {
     void setCancellation(Cancellable c);
     /**
      * The current outstanding request amount.
-     * <p>This method it threadsafe.
+     * <p>This method it thread-safe.
      * @return the current outstanding request amount
      */
     long requested();
@@ -81,7 +81,7 @@ enum BackpressureMode {
          */
         ERROR,
         /**
-         * Buffers (unbounded) all onNext calls until the dowsntream can consume them.
+         * Buffers (unbounded) all onNext calls until the downstream can consume them.
          */
         BUFFER,
         /**
diff --git a/src/main/java/rx/BackpressureOverflow.java b/src/main/java/rx/BackpressureOverflow.java
index ebd98e1b82..b47e40f825 100644
--- a/src/main/java/rx/BackpressureOverflow.java
+++ b/src/main/java/rx/BackpressureOverflow.java
@@ -15,13 +15,15 @@
  */
 package rx;
 
-import rx.annotations.Experimental;
+import rx.annotations.Beta;
 import rx.exceptions.MissingBackpressureException;
 
 /**
  * Generic strategy and default implementations to deal with backpressure buffer overflows.
+ * 
+ * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
  */
-@Experimental
+@Beta
 public final class BackpressureOverflow {
 
     /**
@@ -55,7 +57,7 @@ public interface Strategy {
          * drop the item currently causing backpressure.
          *
          * @return true to request drop of the oldest item, false to drop the newest.
-         * @throws MissingBackpressureException
+         * @throws MissingBackpressureException if the strategy should signal MissingBackpressureException
          */
         boolean mayAttemptDrop() throws MissingBackpressureException;
     }
diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 6cf90313fa..e604fdaf71 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -20,13 +20,13 @@
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import rx.annotations.Experimental;
+import rx.annotations.*;
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.internal.operators.*;
 import rx.internal.util.*;
 import rx.observers.*;
-import rx.plugins.*;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.*;
 
@@ -34,29 +34,14 @@
  * Represents a deferred computation without any value but only indication for completion or exception.
  *
  * The class follows a similar event pattern as Reactive-Streams: onSubscribe (onError|onComplete)?
+ * 
+ * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
  */
-@Experimental
+@Beta
 public class Completable {
     /** The actual subscription action. */
     private final OnSubscribe onSubscribe;
 
-    /**
-     * @deprecated Use {@link OnSubscribe} instead.
-     */
-    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
-    public interface CompletableOnSubscribe extends Action1<CompletableSubscriber> {
-
-    }
-
-    private static OnSubscribe fromOldOnSubscribe(final CompletableOnSubscribe onSubscribe) {
-        return new OnSubscribe() {
-            @Override
-            public void call(final rx.CompletableSubscriber s) {
-                onSubscribe.call(toOldSubscriber(s));
-            }
-        };
-    }
-
     /**
      * Callback used for building deferred computations that takes a CompletableSubscriber.
      */
@@ -64,24 +49,6 @@ public interface OnSubscribe extends Action1<rx.CompletableSubscriber> {
 
     }
 
-    /**
-     * @deprecated Use {@link Operator} instead.
-     */
-    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
-    public interface CompletableOperator extends Func1<CompletableSubscriber, CompletableSubscriber> {
-
-    }
-
-    private static Operator fromOldOperator(final CompletableOperator operator) {
-        requireNonNull(operator);
-        return new Operator() {
-            @Override
-            public rx.CompletableSubscriber call(final rx.CompletableSubscriber subscriber) {
-                return fromOldSubscriber(operator.call(toOldSubscriber(subscriber)));
-            }
-        };
-    }
-
     /**
      * Convenience interface and callback used by the lift operator that given a child CompletableSubscriber,
      * return a parent CompletableSubscriber that does any kind of lifecycle-related transformations.
@@ -90,78 +57,6 @@ public interface Operator extends Func1<rx.CompletableSubscriber, rx.Completable
 
     }
 
-    /**
-     * @deprecated Use {@link rx.CompletableSubscriber} instead.
-     */
-    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
-    public interface CompletableSubscriber {
-        /**
-         * Called once the deferred computation completes normally.
-         */
-        void onCompleted();
-
-        /**
-         * Called once if the deferred computation 'throws' an exception.
-         * @param e the exception, not null.
-         */
-        void onError(Throwable e);
-
-        /**
-         * Called once by the Completable to set a Subscription on this instance which
-         * then can be used to cancel the subscription at any time.
-         * @param d the Subscription instance to call dispose on for cancellation, not null
-         */
-        void onSubscribe(Subscription d);
-    }
-
-    static rx.CompletableSubscriber fromOldSubscriber(final CompletableSubscriber subscriber) {
-        requireNonNull(subscriber);
-        return new rx.CompletableSubscriber() {
-            @Override
-            public void onCompleted() {
-                subscriber.onCompleted();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                subscriber.onError(e);
-            }
-
-            @Override
-            public void onSubscribe(Subscription d) {
-                subscriber.onSubscribe(d);
-            }
-        };
-    }
-
-    static CompletableSubscriber toOldSubscriber(final rx.CompletableSubscriber subscriber) {
-        requireNonNull(subscriber);
-        return new CompletableSubscriber() {
-            @Override
-            public void onCompleted() {
-                subscriber.onCompleted();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                subscriber.onError(e);
-            }
-
-            @Override
-            public void onSubscribe(Subscription d) {
-                subscriber.onSubscribe(d);
-            }
-        };
-    }
-
-    /**
-     * @deprecated Use {@link Transformer} instead.
-     */
-    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
-    public interface CompletableTransformer extends Transformer {
-
-    }
-
     /**
      * Convenience interface and callback used by the compose operator to turn a Completable into another
      * Completable fluently.
@@ -456,17 +351,6 @@ public static Completable concat(Observable<? extends Completable> sources, int
         return create(new CompletableOnSubscribeConcat(sources, prefetch));
     }
 
-    /**
-     * Constructs a Completable instance by wrapping the given old onSubscribe callback.
-     * @param onSubscribe the old CompletableOnSubscribe instance to wrap
-     * @return a Completable instance
-     * @deprecated Use {@link #create(OnSubscribe)}.
-     */
-    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
-    public static Completable create(CompletableOnSubscribe onSubscribe) {
-        return create(fromOldOnSubscribe(onSubscribe));
-    }
-
     /**
      * Constructs a Completable instance by wrapping the given onSubscribe callback.
      * @param onSubscribe the callback which will receive the CompletableSubscriber instances
@@ -1117,14 +1001,6 @@ protected Completable(OnSubscribe onSubscribe) {
         this.onSubscribe = RxJavaHooks.onCreate(onSubscribe);
     }
 
-    /**
-     * @deprecated Use {@link #Completable(OnSubscribe)}.
-     */
-    @Deprecated // TODO Remove constructor after 1.2.0 release. It was never a stable API. Provided only for migration.
-    protected Completable(CompletableOnSubscribe onSubscribe) {
-        this(fromOldOnSubscribe(onSubscribe));
-    }
-
     /**
      * Constructs a Completable instance with the given onSubscribe callback without calling the onCreate
      * hook.
@@ -1136,19 +1012,6 @@ protected Completable(OnSubscribe onSubscribe, boolean useHook) {
         this.onSubscribe = useHook ? RxJavaHooks.onCreate(onSubscribe) : onSubscribe;
     }
 
-    /**
-     * Constructs a Completable instance with the given onSubscribe callback without calling the onCreate
-     * hook.
-     * @param onSubscribe the callback that will receive CompletableSubscribers when they subscribe,
-     * not null (not verified)
-     * @param useHook if false, RxJavaHooks.onCreate won't be called
-     * @deprecated Use {@link #Completable(OnSubscribe, boolean)}.
-     */
-    @Deprecated // TODO Remove constructor after 1.2.0 release. It was never a stable API. Provided only for migration.
-    protected Completable(CompletableOnSubscribe onSubscribe, boolean useHook) {
-        this(fromOldOnSubscribe(onSubscribe), useHook);
-    }
-
     /**
      * Returns a Completable that emits the a terminated event of either this Completable
      * or the other Completable whichever fires first.
@@ -1422,17 +1285,6 @@ public void onSubscribe(Subscription d) {
         });
     }
 
-    /**
-     * Returns a Completable which calls the given onComplete callback if this Completable completes.
-     * @param onComplete the callback to call when this emits an onComplete event
-     * @return the new Completable instance
-     * @throws NullPointerException if onComplete is null
-     * @deprecated Use {@link #doOnCompleted(Action0)} instead.
-     */
-    @Deprecated public final Completable doOnComplete(Action0 onComplete) {
-        return doOnCompleted(onComplete);
-    }
-
     /**
      * Returns a Completable which calls the given onCompleted callback if this Completable completes.
      * @param onCompleted the callback to call when this emits an onComplete event
@@ -1599,34 +1451,6 @@ public void call(Throwable e) {
         }, onTerminate, Actions.empty(), Actions.empty());
     }
 
-    /**
-     * Returns a completable that first runs this Completable
-     * and then the other completable.
-     * <p>
-     * This is an alias for {@link #concatWith(Completable)}.
-     * @param other the other Completable, not null
-     * @return the new Completable instance
-     * @throws NullPointerException if other is null
-     * @deprecated Use {@link #andThen(rx.Completable)} instead.
-     */
-    @Deprecated
-    public final Completable endWith(Completable other) {
-        return andThen(other);
-    }
-
-    /**
-     * Returns an Observable that first runs this Completable instance and
-     * resumes with the given next Observable.
-     * @param <T> the value type of the next Observable
-     * @param next the next Observable to continue
-     * @return the new Observable instance
-     * @deprecated Use {@link #andThen(rx.Observable)} instead.
-     */
-    @Deprecated
-    public final <T> Observable<T> endWith(Observable<T> next) {
-        return andThen(next);
-    }
-
     /**
      * Returns a Completable instance that calls the given onAfterComplete callback after this
      * Completable completes normally.
@@ -1730,18 +1554,6 @@ public void onSubscribe(Subscription d) {
         return null;
     }
 
-    /**
-     * Lifts a CompletableSubscriber transformation into the chain of Completables.
-     * @param onLift the lifting function that transforms the child subscriber with a parent subscriber.
-     * @return the new Completable instance
-     * @throws NullPointerException if onLift is null
-     * @deprecated Use {@link #lift(Operator)}.
-     */
-    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
-    public final Completable lift(CompletableOperator onLift) {
-        return lift(fromOldOperator(onLift));
-    }
-
     /**
      * Lifts a CompletableSubscriber transformation into the chain of Completables.
      * @param onLift the lifting function that transforms the child subscriber with a parent subscriber.
@@ -2200,22 +2012,11 @@ public void onSubscribe(Subscription d) {
         return mad;
     }
 
-    private static void deliverUncaughtException(Throwable e) {
+    static void deliverUncaughtException(Throwable e) {
         Thread thread = Thread.currentThread();
         thread.getUncaughtExceptionHandler().uncaughtException(thread, e);
     }
 
-    /**
-     * Subscribes the given CompletableSubscriber to this Completable instance.
-     * @param s the CompletableSubscriber, not null
-     * @throws NullPointerException if s is null
-     * @deprecated Use {@link #unsafeSubscribe(rx.CompletableSubscriber)}.
-     */
-    @Deprecated // TODO Remove interface after 1.2.0 release. It was never a stable API. Provided only for migration.
-    public final void unsafeSubscribe(CompletableSubscriber s) {
-        unsafeSubscribe(fromOldSubscriber(s));
-    }
-
     /**
      * Subscribes the given CompletableSubscriber to this Completable instance.
      * @param s the CompletableSubscriber, not null
@@ -2268,7 +2069,7 @@ public final <T> void unsafeSubscribe(final Subscriber<T> s) {
      * @param callOnStart if true, the Subscriber.onStart will be called
      * @throws NullPointerException if s is null
      */
-    private final <T> void unsafeSubscribe(final Subscriber<T> s, boolean callOnStart) {
+    private <T> void unsafeSubscribe(final Subscriber<T> s, boolean callOnStart) {
         requireNonNull(s);
         try {
             if (callOnStart) {
diff --git a/src/main/java/rx/Notification.java b/src/main/java/rx/Notification.java
index d9c6e2fff5..565e57fb25 100644
--- a/src/main/java/rx/Notification.java
+++ b/src/main/java/rx/Notification.java
@@ -66,7 +66,7 @@ public static <T> Notification<T> createOnCompleted() {
      * Creates and returns a {@code Notification} of variety {@code Kind.OnCompleted}.
      *
      * @param <T> the actual value type held by the Notification
-     * @param type
+     * @param type the type token to help with type inference of {@code <T>}
      * @deprecated this method does the same as {@link #createOnCompleted()} and does not use the passed in type hence it's useless.
      * @return an {@code OnCompleted} variety of {@code Notification}
      */
@@ -217,14 +217,7 @@ public boolean equals(Object obj) {
         }
 
         Notification<?> notification = (Notification<?>) obj;
-        if (notification.getKind() != getKind()) {
-            return false;
-        }
-
-        if (!(value == notification.value || (value != null && value.equals(notification.value)))) {
-            return false;
-        }
+        return notification.getKind() == getKind() && (value == notification.value || (value != null && value.equals(notification.value))) && (throwable == notification.throwable || (throwable != null && throwable.equals(notification.throwable)));
 
-        return (throwable == notification.throwable || (throwable != null && throwable.equals(notification.throwable)));
     }
 }
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 79f19eb31f..2aba15801c 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -135,9 +135,8 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
      * @see SyncOnSubscribe#createStateless(Action1)
      * @see SyncOnSubscribe#createStateless(Action1, Action0)
      * @see <a href="http://reactivex.io/documentation/operators/create.html">ReactiveX operators documentation: Create</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.2
      */
-    @Beta
     public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe) {
         return create((OnSubscribe<T>)syncOnSubscribe);
     }
@@ -202,21 +201,6 @@ public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<
         // cover for generics insanity
     }
 
-    /**
-     * Passes all emitted values from this Observable to the provided conversion function to be collected and
-     * returned as a single value. Note that it is legal for a conversion function to return an Observable
-     * (enabling chaining).
-     *
-     * @param <R> the output type of the conversion function
-     * @param conversion a function that converts from the source {@code Observable<T>} to an {@code R}
-     * @return an instance of R created by the provided conversion function
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
-     */
-    @Experimental @Deprecated // TODO remove method some time after 1.2.0 release. It was never a stable API.
-    public <R> R extend(Func1<? super OnSubscribe<T>, ? extends R> conversion) {
-        return conversion.call(new OnSubscribeExtend<T>(this));
-    }
-
     /**
      * Transforms a OnSubscribe.call() into an Observable.subscribe() call.
      * <p>Note: has to be in Observable because it calls the package-private subscribe() method
@@ -342,9 +326,8 @@ public final <R> R to(Func1<? super Observable<T>, R> converter) {
      * @throws NoSuchElementException
      *             if the source observable emits no items
      * @see <a href="http://reactivex.io/documentation/single.html">ReactiveX documentation: Single</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.2
      */
-    @Beta
     public Single<T> toSingle() {
         return new Single<T>(OnSubscribeSingle.create(this));
     }
@@ -372,7 +355,7 @@ public Single<T> toSingle() {
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical
      *        with the release number)
      */
-    @Experimental
+    @Beta
     public Completable toCompletable() {
         return Completable.fromObservable(this);
     }
@@ -1461,9 +1444,10 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * @param <T> the common element base type
      * @param sources the Observable sequence of Observables
      * @return the new Observable with the concatenating behavior
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
-    @Experimental
+    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends Observable<? extends T>> sources) {
         return sources.concatMapDelayError((Func1)UtilityFunctions.identity());
     }
@@ -1485,8 +1469,9 @@ public static <T> Observable<T> concatDelayError(Observable<? extends Observable
      * @param <T> the common element base type
      * @param sources the Iterable sequence of Observables
      * @return the new Observable with the concatenating behavior
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Observable<T> concatDelayError(Iterable<? extends Observable<? extends T>> sources) {
         return concatDelayError(from(sources));
     }
@@ -1511,8 +1496,9 @@ public static <T> Observable<T> concatDelayError(Iterable<? extends Observable<?
      * @param t2
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2) {
         return concatDelayError(just(t1, t2));
     }
@@ -1539,8 +1525,9 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t3
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2,Observable<? extends T> t3 ) {
         return concatDelayError(just(t1, t2, t3));
     }
@@ -1569,8 +1556,9 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t4
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
         return concatDelayError(just(t1, t2, t3, t4));
     }
@@ -1601,8 +1589,9 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t5
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
         return concatDelayError(just(t1, t2, t3, t4, t5));
     }
@@ -1635,8 +1624,9 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t6
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
         return concatDelayError(just(t1, t2, t3, t4, t5, t6));
     }
@@ -1671,8 +1661,9 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t7
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
         return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7));
     }
@@ -1709,8 +1700,9 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t8
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
         return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7, t8));
     }
@@ -1749,8 +1741,9 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t9
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
         return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7, t8, t9));
     }
@@ -1983,53 +1976,6 @@ public static <T> Observable<T> from(T[] array) {
         return create(new OnSubscribeFromArray<T>(array));
     }
 
-    /**
-     * Provides an API (via a cold Observable) that bridges the reactive world with the callback-style,
-     * generally non-backpressured world.
-     * <p>
-     * Example:
-     * <pre><code>
-     * Observable.&lt;Event&gt;fromAsync(emitter -&gt; {
-     *     Callback listener = new Callback() {
-     *         &#64;Override
-     *         public void onEvent(Event e) {
-     *             emitter.onNext(e);
-     *             if (e.isLast()) {
-     *                 emitter.onCompleted();
-     *             }
-     *         }
-     *
-     *         &#64;Override
-     *         public void onFailure(Exception e) {
-     *             emitter.onError(e);
-     *         }
-     *     };
-     *
-     *     AutoCloseable c = api.someMethod(listener);
-     *
-     *     emitter.setCancellation(c::close);
-     *
-     * }, BackpressureMode.BUFFER);
-     * </code></pre>
-     * <p>
-     * You should call the AsyncEmitter's onNext, onError and onCompleted methods in a serialized fashion. The
-     * rest of its methods are threadsafe.
-     *
-     * @param <T> the element type
-     * @param asyncEmitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
-     * @param backpressure the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
-     * @return the new Observable instance
-     * @see AsyncEmitter
-     * @see AsyncEmitter.BackpressureMode
-     * @see AsyncEmitter.Cancellable
-     * @deprecated renamed, use {@link #fromEmitter(Action1, rx.AsyncEmitter.BackpressureMode)} instead
-     */
-    @Experimental
-    @Deprecated // will be removed in 1.2.0
-    public static <T> Observable<T> fromAsync(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) {
-        return fromEmitter(asyncEmitter, backpressure);
-    }
-
     /**
      * Provides an API (via a cold Observable) that bridges the reactive world with the callback-style,
      * generally non-backpressured world.
@@ -2060,7 +2006,7 @@ public static <T> Observable<T> fromAsync(Action1<AsyncEmitter<T>> asyncEmitter,
      * </code></pre>
      * <p>
      * You should call the AsyncEmitter's onNext, onError and onCompleted methods in a serialized fashion. The
-     * rest of its methods are threadsafe.
+     * rest of its methods are thread-safe.
      *
      * @param <T> the element type
      * @param emitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
@@ -2098,9 +2044,8 @@ public static <T> Observable<T> fromEmitter(Action1<AsyncEmitter<T>> emitter, As
      *         the type of the item emitted by the Observable
      * @return an Observable whose {@link Observer}s' subscriptions trigger an invocation of the given function
      * @see #defer(Func0)
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.2
      */
-    @Beta
     public static <T> Observable<T> fromCallable(Callable<? extends T> func) {
         return create(new OnSubscribeFromCallable<T>(func));
     }
@@ -3073,7 +3018,7 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends Observable<
      * @see <a href="http://reactivex.io/documentation/operators/merge.html">ReactiveX operators documentation: Merge</a>
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Observable<T> mergeDelayError(Observable<? extends Observable<? extends T>> source, int maxConcurrent) {
         return source.lift(OperatorMerge.<T>instance(true, maxConcurrent));
     }
@@ -3690,7 +3635,7 @@ public static <T> Observable<T> switchOnNext(Observable<? extends Observable<? e
      * @Experimental The behavior of this can change at any time.
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Observable<T> switchOnNextDelayError(Observable<? extends Observable<? extends T>> sequenceOfSequences) {
         return sequenceOfSequences.lift(OperatorSwitch.<T>instance(true));
     }
@@ -3867,7 +3812,7 @@ public static <T, Resource> Observable<T> using(
      * @Experimental The behavior of this can change at any time.
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T, Resource> Observable<T> using(
             final Func0<Resource> resourceFactory,
             final Func1<? super Resource, ? extends Observable<? extends T>> observableFactory,
@@ -5159,7 +5104,7 @@ public final <R> Observable<R> collect(Func0<R> stateFactory, final Action2<R, ?
      *  <dd>{@code concatMap} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
-     * @param <R> the type of the inner Observable sources and thus the ouput type
+     * @param <R> the type of the inner Observable sources and thus the output type
      * @param func
      *            a function that, when applied to an item emitted by the source Observable, returns an
      *            Observable
@@ -5195,8 +5140,9 @@ public final <R> Observable<R> concatMap(Func1<? super T, ? extends Observable<?
      * @param <R> the result value type
      * @param func the function that maps the items of this Observable into the inner Observables.
      * @return the new Observable instance with the concatenation behavior
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final <R> Observable<R> concatMapDelayError(Func1<? super T, ? extends Observable<?extends R>> func) {
         if (this instanceof ScalarSynchronousObservable) {
             ScalarSynchronousObservable<T> scalar = (ScalarSynchronousObservable<T>) this;
@@ -5687,8 +5633,9 @@ public final <U> Observable<T> delaySubscription(Func0<? extends Observable<U>>
      *        to this Observable.
      * @return an Observable that delays the subscription to this Observable
      *         until the other Observable emits an element or completes normally.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final <U> Observable<T> delaySubscription(Observable<U> other) {
         if (other == null) {
             throw new NullPointerException();
@@ -5833,7 +5780,7 @@ public final <U> Observable<T> distinctUntilChanged(Func1<? super T, ? extends U
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical
      *        with the release number)
      */
-    @Experimental
+    @Beta
     public final Observable<T> distinctUntilChanged(Func2<? super T, ? super T, Boolean> comparator) {
         return lift(new OperatorDistinctUntilChanged<T, T>(comparator));
     }
@@ -5985,10 +5932,8 @@ public final Observable<T> doOnNext(final Action1<? super T> onNext) {
      * @return the source {@code Observable} modified so as to call this Action when appropriate
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators
      *      documentation: Do</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical
-     *        with the release number)
+     * @since 1.2
      */
-    @Beta
     public final Observable<T> doOnRequest(final Action1<Long> onRequest) {
         return lift(new OperatorDoOnRequest<T>(onRequest));
     }
@@ -6096,7 +6041,7 @@ public final Observable<T> doOnUnsubscribe(final Action0 unsubscribe) {
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(Observable<? extends T> o1, Observable<? extends T> o2) {
         return concatEager(Arrays.asList(o1, o2));
@@ -6122,7 +6067,7 @@ public static <T> Observable<T> concatEager(Observable<? extends T> o1, Observab
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6152,7 +6097,7 @@ public static <T> Observable<T> concatEager(
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6183,7 +6128,7 @@ public static <T> Observable<T> concatEager(
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6216,7 +6161,7 @@ public static <T> Observable<T> concatEager(
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6250,7 +6195,7 @@ public static <T> Observable<T> concatEager(
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6286,7 +6231,7 @@ public static <T> Observable<T> concatEager(
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6323,7 +6268,7 @@ public static <T> Observable<T> concatEager(
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6353,7 +6298,7 @@ public static <T> Observable<T> concatEager(
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public static <T> Observable<T> concatEager(Iterable<? extends Observable<? extends T>> sources) {
         return Observable.from(sources).concatMapEager((Func1)UtilityFunctions.identity());
@@ -6378,7 +6323,7 @@ public static <T> Observable<T> concatEager(Iterable<? extends Observable<? exte
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public static <T> Observable<T> concatEager(Iterable<? extends Observable<? extends T>> sources, int capacityHint) {
         return Observable.from(sources).concatMapEager((Func1)UtilityFunctions.identity(), capacityHint);
@@ -6402,7 +6347,7 @@ public static <T> Observable<T> concatEager(Iterable<? extends Observable<? exte
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public static <T> Observable<T> concatEager(Observable<? extends Observable<? extends T>> sources) {
         return sources.concatMapEager((Func1)UtilityFunctions.identity());
@@ -6427,7 +6372,7 @@ public static <T> Observable<T> concatEager(Observable<? extends Observable<? ex
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public static <T> Observable<T> concatEager(Observable<? extends Observable<? extends T>> sources, int capacityHint) {
         return sources.concatMapEager((Func1)UtilityFunctions.identity(), capacityHint);
@@ -6453,7 +6398,7 @@ public static <T> Observable<T> concatEager(Observable<? extends Observable<? ex
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observable<? extends R>> mapper) {
         return concatMapEager(mapper, RxRingBuffer.SIZE);
     }
@@ -6479,7 +6424,7 @@ public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observa
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observable<? extends R>> mapper, int capacityHint) {
         if (capacityHint < 1) {
             throw new IllegalArgumentException("capacityHint > 0 required but it was " + capacityHint);
@@ -6509,7 +6454,7 @@ public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observa
      * @return the new Observable instance with the specified concatenation behavior
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observable<? extends R>> mapper, int capacityHint, int maxConcurrent) {
         if (capacityHint < 1) {
             throw new IllegalArgumentException("capacityHint > 0 required but it was " + capacityHint);
@@ -6528,7 +6473,7 @@ public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observa
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded manner
-     *  (i.e., no backkpressure applied to it).</dd>
+     *  (i.e., no backpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code elementAt} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6555,7 +6500,7 @@ public final Observable<T> elementAt(int index) {
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded manner
-     *  (i.e., no backkpressure applied to it).</dd>
+     *  (i.e., no backpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code elementAtOrDefault} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6586,7 +6531,7 @@ public final Observable<T> elementAtOrDefault(int index, T defaultValue) {
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>The operator honors backpressure from downstream and consumes the source {@code Observable} in an unbounded manner
-     *  (i.e., no backkpressure applied to it).</dd>
+     *  (i.e., no backpressure applied to it).</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code exists} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
@@ -6823,9 +6768,8 @@ public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? e
      *         by the source Observable and merging the results of the Observables obtained from this
      *         transformation
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.2
      */
-    @Beta
     public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends R>> func, int maxConcurrent) {
         if (getClass() == ScalarSynchronousObservable.class) {
             return ((ScalarSynchronousObservable<T>)this).scalarFlatMap(func);
@@ -6896,9 +6840,8 @@ public final <R> Observable<R> flatMap(
      * @return an Observable that emits the results of merging the Observables returned from applying the
      *         specified functions to the emissions and notifications of the source Observable
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.2
      */
-    @Beta
     public final <R> Observable<R> flatMap(
             Func1<? super T, ? extends Observable<? extends R>> onNext,
             Func1<? super Throwable, ? extends Observable<? extends R>> onError,
@@ -6964,9 +6907,8 @@ public final <U, R> Observable<R> flatMap(final Func1<? super T, ? extends Obser
      * @return an Observable that emits the results of applying a function to a pair of values emitted by the
      *         source Observable and the collection Observable
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.2
      */
-    @Beta
     public final <U, R> Observable<R> flatMap(final Func1<? super T, ? extends Observable<? extends U>> collectionSelector,
             final Func2<? super T, ? super U, ? extends R> resultSelector, int maxConcurrent) {
         return merge(lift(new OperatorMapPair<T, U, R>(collectionSelector, resultSelector)), maxConcurrent);
@@ -7026,9 +6968,8 @@ public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterab
      * @throws IllegalArgumentException
      *             if {@code maxConcurrent} is less than or equal to 0
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.2
      */
-    @Beta
     public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterable<? extends R>> collectionSelector, int maxConcurrent) {
         return OnSubscribeFlattenIterable.createFrom(this, collectionSelector, maxConcurrent);
     }
@@ -7098,10 +7039,9 @@ public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Ite
      * @throws IllegalArgumentException
      *             if {@code maxConcurrent} is less than or equal to 0
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.2
      */
     @SuppressWarnings("cast")
-    @Beta
     public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterable<? extends U>> collectionSelector,
             Func2<? super T, ? super U, ? extends R> resultSelector, int maxConcurrent) {
         return (Observable<R>)flatMap(OperatorMapPair.convertSelector(collectionSelector), resultSelector, maxConcurrent);
@@ -7698,7 +7638,7 @@ public final Observable<T> observeOn(Scheduler scheduler) {
      *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
      *  pops up; look for sources up the chain that don't support backpressure,
      *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
-     *  of the {@code onBackpressureXXX} opertors <strong>before</strong> applying {@code observeOn} itself.</dd>
+     *  of the {@code onBackpressureXXX} operators <strong>before</strong> applying {@code observeOn} itself.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -7729,7 +7669,7 @@ public final Observable<T> observeOn(Scheduler scheduler, int bufferSize) {
      *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
      *  pops up; look for sources up the chain that don't support backpressure,
      *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
-     *  of the {@code onBackpressureXXX} opertors <strong>before</strong> applying {@code observeOn} itself.</dd>
+     *  of the {@code onBackpressureXXX} operators <strong>before</strong> applying {@code observeOn} itself.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -7764,7 +7704,7 @@ public final Observable<T> observeOn(Scheduler scheduler, boolean delayError) {
      *  expectation will lead to {@code MissingBackpressureException}. This is the most common operator where the exception
      *  pops up; look for sources up the chain that don't support backpressure,
      *  such as {@code interval}, {@code timer}, {code PublishSubject} or {@code BehaviorSubject} and apply any
-     *  of the {@code onBackpressureXXX} opertors <strong>before</strong> applying {@code observeOn} itself.</dd>
+     *  of the {@code onBackpressureXXX} operators <strong>before</strong> applying {@code observeOn} itself.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -7916,7 +7856,7 @@ public final Observable<T> onBackpressureBuffer(long capacity, Action0 onOverflo
      * @see <a href="http://reactivex.io/documentation/operators/backpressure.html">ReactiveX operators documentation: backpressure operators</a>
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Observable<T> onBackpressureBuffer(long capacity, Action0 onOverflow, BackpressureOverflow.Strategy overflowStrategy) {
         return lift(new OperatorOnBackpressureBuffer<T>(capacity, onOverflow, overflowStrategy));
     }
@@ -10417,7 +10357,7 @@ public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<?
      * @Experimental The behavior of this can change at any time.
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final <R> Observable<R> switchMapDelayError(Func1<? super T, ? extends Observable<? extends R>> func) {
         return switchOnNextDelayError(map(func));
     }
@@ -11756,7 +11696,7 @@ public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Intege
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Observable<List<T>> toSortedList(int initialCapacity) {
         return lift(new OperatorToObservableSortedList<T>(initialCapacity));
     }
@@ -11784,7 +11724,7 @@ public final Observable<List<T>> toSortedList(int initialCapacity) {
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Integer> sortFunction, int initialCapacity) {
         return lift(new OperatorToObservableSortedList<T>(sortFunction, initialCapacity));
     }
diff --git a/src/main/java/rx/Scheduler.java b/src/main/java/rx/Scheduler.java
index a868751486..9dc789d463 100644
--- a/src/main/java/rx/Scheduler.java
+++ b/src/main/java/rx/Scheduler.java
@@ -70,7 +70,7 @@ public abstract class Scheduler {
     /**
      * Sequential Scheduler for executing actions on a single thread or event loop.
      * <p>
-     * Unsubscribing the {@link Worker} unschedules all outstanding work and allows resources cleanup.
+     * Unsubscribing the {@link Worker} cancels all outstanding work and allows resources cleanup.
      */
     public abstract static class Worker implements Subscription {
 
@@ -79,24 +79,24 @@ public abstract static class Worker implements Subscription {
          *
          * @param action
          *            Action to schedule
-         * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
+         * @return a subscription to be able to prevent or cancel the execution of the action
          */
         public abstract Subscription schedule(Action0 action);
 
         /**
          * Schedules an Action for execution at some point in the future.
          * <p>
-         * Note to implementors: non-positive {@code delayTime} should be regarded as undelayed schedule, i.e.,
+         * Note to implementors: non-positive {@code delayTime} should be regarded as non-delayed schedule, i.e.,
          * as if the {@link #schedule(rx.functions.Action0)} was called.
          *
          * @param action
          *            the Action to schedule
          * @param delayTime
-         *            time to wait before executing the action; non-positive values indicate an undelayed
+         *            time to wait before executing the action; non-positive values indicate an non-delayed
          *            schedule
          * @param unit
          *            the time unit of {@code delayTime}
-         * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
+         * @return a subscription to be able to prevent or cancel the execution of the action
          */
         public abstract Subscription schedule(final Action0 action, final long delayTime, final TimeUnit unit);
 
@@ -106,19 +106,19 @@ public abstract static class Worker implements Subscription {
          * concurrently). Each scheduler that can do periodic scheduling in a better way should override this.
          * <p>
          * Note to implementors: non-positive {@code initialTime} and {@code period} should be regarded as
-         * undelayed scheduling of the first and any subsequent executions.
+         * non-delayed scheduling of the first and any subsequent executions.
          *
          * @param action
          *            the Action to execute periodically
          * @param initialDelay
          *            time to wait before executing the action for the first time; non-positive values indicate
-         *            an undelayed schedule
+         *            an non-delayed schedule
          * @param period
          *            the time interval to wait each time in between executing the action; non-positive values
          *            indicate no delay between repeated schedules
          * @param unit
          *            the time unit of {@code period}
-         * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
+         * @return a subscription to be able to prevent or cancel the execution of the action
          */
         public Subscription schedulePeriodically(final Action0 action, long initialDelay, long period, TimeUnit unit) {
             final long periodInNanos = unit.toNanos(period);
@@ -211,7 +211,7 @@ public long now() {
      * size thread pool:
      *
      * <pre>
-     * Scheduler limitSched = Schedulers.computation().when(workers -> {
+     * Scheduler limitScheduler = Schedulers.computation().when(workers -> {
      * 	// use merge max concurrent to limit the number of concurrent
      * 	// callbacks two at a time
      * 	return Completable.merge(Observable.merge(workers), 2);
@@ -229,7 +229,7 @@ public long now() {
      * subscription to the second.
      *
      * <pre>
-     * Scheduler limitSched = Schedulers.computation().when(workers -> {
+     * Scheduler limitScheduler = Schedulers.computation().when(workers -> {
      * 	// use merge max concurrent to limit the number of concurrent
      * 	// Observables two at a time
      * 	return Completable.merge(Observable.merge(workers, 2));
@@ -242,7 +242,7 @@ public long now() {
      * bucket algorithm).
      *
      * <pre>
-     * Scheduler slowSched = Schedulers.computation().when(workers -> {
+     * Scheduler slowScheduler = Schedulers.computation().when(workers -> {
      * 	// use concatenate to make each worker happen one at a time.
      * 	return Completable.concat(workers.map(actions -> {
      * 		// delay the starting of the next worker by 1 second.
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 99e7522451..5d83ec45d4 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -47,9 +47,8 @@
  *
  * @param <T>
  *            the type of the item emitted by the Single
- * @since (If this class graduates from "Experimental" replace this parenthetical with the release number)
+ * @since 1.2
  */
-@Beta
 public class Single<T> {
 
     final Observable.OnSubscribe<T> onSubscribe;
@@ -158,7 +157,7 @@ public interface OnSubscribe<T> extends Action1<SingleSubscriber<? super T>> {
      * @return a Single that is the result of applying the lifted Operator to the source Single
      * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Implementing-Your-Own-Operators">RxJava wiki: Implementing Your Own Operators</a>
      */
-    @Experimental
+    @Beta
     public final <R> Single<R> lift(final Operator<? extends R, ? super T> lift) {
         return new Single<R>(new Observable.OnSubscribe<R>() {
             @Override
@@ -210,9 +209,18 @@ public <R> Single<R> compose(Transformer<? super T, ? extends R> transformer) {
     }
 
     /**
-     * Transformer function used by {@link #compose}.
+     * Convenience type that allows a function to fluently transform a
+     * Single into another Single via {@link #compose}.
+     * <pre>
+     *     Transformer&lt;Integer, Integer> transformer = s ->
+     *         s.subscribeOn(Schedulers.io())
+     *          .observeOn(AndroidSchedulers.mainThread());
+     *
+     *     Single.just(1)
+     *     .compose(transformer)
+     *     .subscribe(System.out::println);
+     * </pre>
      *
-     * @warn more complete description needed
      * @param <T> the source Single's value type
      * @param <R> the transformed Single's value type
      */
@@ -221,35 +229,14 @@ public interface Transformer<T, R> extends Func1<Single<T>, Single<R>> {
     }
 
     /**
+     * Hides the identity of this Single.
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Single.toObservable.png" alt="">
-     *
-     * @warn more complete description needed
      */
     private static <T> Observable<T> asObservable(Single<T> t) {
         // is this sufficient, or do I need to keep the outer Single and subscribe to it?
         return Observable.create(t.onSubscribe);
     }
 
-    /**
-     * INTERNAL: Used with lift and operators.
-     *
-     * Converts the source {@code Single<T>} into an {@code Single<Observable<T>>} that emits an Observable
-     * that emits the same emission as the source Single.
-     * <p>
-     * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Single.nest.png" alt="">
-     * <dl>
-     * <dt><b>Scheduler:</b></dt>
-     * <dd>{@code nest} does not operate by default on a particular {@link Scheduler}.</dd>
-     * </dl>
-     *
-     * @return a Single that emits an Observable that emits the same item as the source Single
-     * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
-     */
-    @SuppressWarnings("unused")
-    private Single<Observable<T>> nest() {
-        return Single.just(asObservable(this));
-    }
-
     /* *********************************************************************************************************
      * Operators Below Here
      * *********************************************************************************************************
@@ -614,7 +601,6 @@ public static <T> Single<T> from(Future<? extends T> future, Scheduler scheduler
      *         the type of the item emitted by the {@link Single}.
      * @return a {@link Single} whose {@link Observer}s' subscriptions trigger an invocation of the given function.
      */
-    @Beta
     public static <T> Single<T> fromCallable(final Callable<? extends T> func) {
         return create(new OnSubscribe<T>() {
             @Override
@@ -1411,10 +1397,9 @@ public final <R> Observable<R> flatMapObservable(Func1<? super T, ? extends Obse
      *            Completable
      * @return the Completable returned from {@code func} when applied to the item emitted by the source Single
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
-     * @Experimental The behavior of this can change at any time.
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Completable flatMapCompletable(final Func1<? super T, ? extends Completable> func) {
         return Completable.create(new CompletableFlatMapSingleToCompletable<T>(this, func));
     }
@@ -1547,7 +1532,7 @@ public final Single<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunctio
      * @Experimental The behavior of this can change at any time.
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Single<T> onErrorResumeNext(Single<? extends T> resumeSingleInCaseOfError) {
         return new Single<T>(SingleOperatorOnErrorResumeNext.withOther(this, resumeSingleInCaseOfError));
     }
@@ -1581,7 +1566,7 @@ public final Single<T> onErrorResumeNext(Single<? extends T> resumeSingleInCaseO
      * @Experimental The behavior of this can change at any time.
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Single<T> onErrorResumeNext(final Func1<Throwable, ? extends Single<? extends T>> resumeFunctionInCaseOfError) {
         return new Single<T>(SingleOperatorOnErrorResumeNext.withFunction(this, resumeFunctionInCaseOfError));
     }
@@ -1946,7 +1931,7 @@ public void call(final SingleSubscriber<? super T> t) {
                 w.schedule(new Action0() {
                     @Override
                     public void call() {
-                        SingleSubscriber<T> ssub = new SingleSubscriber<T>() {
+                        SingleSubscriber<T> single = new SingleSubscriber<T>() {
                             @Override
                             public void onSuccess(T value) {
                                 try {
@@ -1966,9 +1951,9 @@ public void onError(Throwable error) {
                             }
                         };
 
-                        t.add(ssub);
+                        t.add(single);
 
-                        Single.this.subscribe(ssub);
+                        Single.this.subscribe(single);
                     }
                 });
             }
@@ -2241,7 +2226,7 @@ public final Observable<T> toObservable() {
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical
      *        with the release number).
      */
-    @Experimental
+    @Beta
     public final Completable toCompletable() {
         return Completable.fromSingle(this);
     }
@@ -2357,7 +2342,7 @@ public final Single<T> timeout(long timeout, TimeUnit timeUnit, Single<? extends
      * @return a {@code BlockingSingle} version of this Single.
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
-    @Experimental
+    @Beta
     public final BlockingSingle<T> toBlocking() {
         return BlockingSingle.from(this);
     }
@@ -2408,7 +2393,7 @@ public final <T2, R> Single<R> zipWith(Single<? extends T2> other, Func2<? super
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Single<T> doOnError(final Action1<Throwable> onError) {
         if (onError == null) {
             throw new IllegalArgumentException("onError is null");
@@ -2506,8 +2491,9 @@ public void call(final Throwable throwable) {
      *            the action that gets called when an observer subscribes to this {@code Single}
      * @return the source {@code Single} modified so as to call this Action when appropriate
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Single<T> doOnSubscribe(final Action0 subscribe) {
         return lift(new OperatorDoOnSubscribe<T>(subscribe));
     }
@@ -2530,8 +2516,9 @@ public final Single<T> doOnSubscribe(final Action0 subscribe) {
      *            the {@link Scheduler} to use for delaying
      * @return the source Single shifted in time by the specified delay
      * @see <a href="http://reactivex.io/documentation/operators/delay.html">ReactiveX operators documentation: Delay</a>
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Single<T> delay(long delay, TimeUnit unit, Scheduler scheduler) {
         return lift(new OperatorDelay<T>(delay, unit, scheduler));
     }
@@ -2552,8 +2539,9 @@ public final Single<T> delay(long delay, TimeUnit unit, Scheduler scheduler) {
      *            the {@link TimeUnit} in which {@code period} is defined
      * @return the source Single shifted in time by the specified delay
      * @see <a href="http://reactivex.io/documentation/operators/delay.html">ReactiveX operators documentation: Delay</a>
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Single<T> delay(long delay, TimeUnit unit) {
         return delay(delay, unit, Schedulers.computation());
     }
@@ -2581,8 +2569,9 @@ public final Single<T> delay(long delay, TimeUnit unit) {
      * @return a {@link Single} whose {@link Observer}s' subscriptions trigger an invocation of the given
      *         {@link Single} factory function.
      * @see <a href="http://reactivex.io/documentation/operators/defer.html">ReactiveX operators documentation: Defer</a>
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T> Single<T> defer(final Callable<Single<T>> singleFactory) {
         return create(new OnSubscribe<T>() {
             @Override
@@ -2616,8 +2605,9 @@ public void call(SingleSubscriber<? super T> singleSubscriber) {
      *            the action that gets called when this {@link Single} is unsubscribed.
      * @return the source {@link Single} modified so as to call this Action when appropriate.
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Single<T> doOnUnsubscribe(final Action0 action) {
         return lift(new OperatorDoOnUnsubscribe<T>(action));
     }
@@ -2637,8 +2627,9 @@ public final Single<T> doOnUnsubscribe(final Action0 action) {
      * @return a {@link Single} that emits the same item or error as the source {@link Single}, then invokes the
      *         {@link Action0}
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Single<T> doAfterTerminate(Action0 action) {
         return create(new SingleDoAfterTerminate<T>(this, action));
     }
@@ -2777,7 +2768,7 @@ public final Single<T> retry(Func2<Integer, Throwable, Boolean> predicate) {
      * }).subscribe(...);
      * </code></pre>
      * <p>
-     * Note that you must compose over the input {@code Observable} provided in the function call because {@retryWhen} expects
+     * Note that you must compose over the input {@code Observable} provided in the function call because {@link #retryWhen} expects
      * an emission of the exception to be matched by an event from the handler Observable.
      * <p>
      *
@@ -2819,7 +2810,7 @@ public final Single<T> retryWhen(final Func1<Observable<? extends Throwable>, ?
      * @return the Single whose lifetime controls the lifetime of the dependent resource object
      * @see <a href="http://reactivex.io/documentation/operators/using.html">ReactiveX operators documentation: Using</a>
      */
-    @Experimental
+    @Beta
     public static <T, Resource> Single<T> using(
             final Func0<Resource> resourceFactory,
             final Func1<? super Resource, ? extends Single<? extends T>> singleFactory,
@@ -2856,7 +2847,7 @@ public static <T, Resource> Single<T> using(
      * @Experimental The behavior of this can change at any time.
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static <T, Resource> Single<T> using(
             final Func0<Resource> resourceFactory,
             final Func1<? super Resource, ? extends Single<? extends T>> singleFactory,
@@ -2889,8 +2880,9 @@ public static <T, Resource> Single<T> using(
      *        to this Single.
      * @return a Single that delays the subscription to this Single
      *         until the Observable emits an element or completes normally.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public final Single<T> delaySubscription(Observable<?> other) {
         if (other == null) {
             throw new NullPointerException();
diff --git a/src/main/java/rx/SingleSubscriber.java b/src/main/java/rx/SingleSubscriber.java
index b9e4f6739a..05270748ad 100644
--- a/src/main/java/rx/SingleSubscriber.java
+++ b/src/main/java/rx/SingleSubscriber.java
@@ -15,7 +15,6 @@
  */
 package rx;
 
-import rx.annotations.Beta;
 import rx.internal.util.SubscriptionList;
 
 /**
@@ -29,9 +28,8 @@
  * @see <a href="http://reactivex.io/documentation/observable.html">ReactiveX documentation: Observable</a>
  * @param <T>
  *          the type of item the SingleSubscriber expects to observe
- * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ * @since 1.2
  */
-@Beta
 public abstract class SingleSubscriber<T> implements Subscription {
 
     private final SubscriptionList cs = new SubscriptionList();
diff --git a/src/main/java/rx/Subscriber.java b/src/main/java/rx/Subscriber.java
index 1a43864b89..6eb197cba8 100644
--- a/src/main/java/rx/Subscriber.java
+++ b/src/main/java/rx/Subscriber.java
@@ -144,7 +144,7 @@ protected final void request(long n) {
 
         // if producer is set then we will request from it
         // otherwise we increase the requested count by n
-        Producer producerToRequestFrom = null;
+        Producer producerToRequestFrom;
         synchronized (this) {
             if (producer != null) {
                 producerToRequestFrom = producer;
diff --git a/src/main/java/rx/Subscription.java b/src/main/java/rx/Subscription.java
index 0a5e7f0408..ab0f03cf34 100644
--- a/src/main/java/rx/Subscription.java
+++ b/src/main/java/rx/Subscription.java
@@ -30,7 +30,7 @@ public interface Subscription {
      * Stops the receipt of notifications on the {@link Subscriber} that was registered when this Subscription
      * was received.
      * <p>
-     * This allows unregistering an {@link Subscriber} before it has finished receiving all events (i.e. before
+     * This allows deregistering an {@link Subscriber} before it has finished receiving all events (i.e. before
      * onCompleted is called).
      */
     void unsubscribe();
diff --git a/src/main/java/rx/annotations/Beta.java b/src/main/java/rx/annotations/Beta.java
index f03bdc40ac..0bcb9d34c4 100644
--- a/src/main/java/rx/annotations/Beta.java
+++ b/src/main/java/rx/annotations/Beta.java
@@ -34,7 +34,7 @@
  *
  * <p>It is generally safe for <i>applications</i> to depend on beta APIs, at
  * the cost of some extra work during upgrades. However it is generally
- * inadvisable for <i>libraries</i> (which get included on users' CLASSPATHs,
+ * inadvisable for <i>libraries</i> (which get included on users' {@code CLASSPATH}s,
  * outside the library developers' control) to do so.
  *
  **/
diff --git a/src/main/java/rx/exceptions/CompositeException.java b/src/main/java/rx/exceptions/CompositeException.java
index 154ce4ed6a..8c40d37bb7 100644
--- a/src/main/java/rx/exceptions/CompositeException.java
+++ b/src/main/java/rx/exceptions/CompositeException.java
@@ -18,7 +18,7 @@
 import java.io.*;
 import java.util.*;
 
-import rx.annotations.Experimental;
+import rx.annotations.Beta;
 
 /**
  * Represents an exception that is a composite of one or more other exceptions. A {@code CompositeException}
@@ -72,6 +72,12 @@ public CompositeException(String messagePrefix, Collection<? extends Throwable>
         this.message = exceptions.size() + " exceptions occurred. ";
     }
 
+    /**
+     * Constructs a CompositeException instance with the Throwable elements
+     * of the supplied Collection.
+     * <p>Null values are replaced by {@link NullPointerException}.
+     * @param errors the collection of errors
+     */
     public CompositeException(Collection<? extends Throwable> errors) {
         this(null, errors);
     }
@@ -80,7 +86,7 @@ public CompositeException(Collection<? extends Throwable> errors) {
      * Constructs a CompositeException instance with the supplied initial Throwables.
      * @param errors the array of Throwables
      */
-    @Experimental
+    @Beta
     public CompositeException(Throwable... errors) {
         Set<Throwable> deDupedExceptions = new LinkedHashSet<Throwable>();
         List<Throwable> localExceptions = new ArrayList<Throwable>();
@@ -192,30 +198,30 @@ public void printStackTrace(PrintWriter s) {
      *            stream to print to
      */
     private void printStackTrace(PrintStreamOrWriter s) {
-        StringBuilder bldr = new StringBuilder(128);
-        bldr.append(this).append('\n');
+        StringBuilder b = new StringBuilder(128);
+        b.append(this).append('\n');
         for (StackTraceElement myStackElement : getStackTrace()) {
-            bldr.append("\tat ").append(myStackElement).append('\n');
+            b.append("\tat ").append(myStackElement).append('\n');
         }
         int i = 1;
         for (Throwable ex : exceptions) {
-            bldr.append("  ComposedException ").append(i).append(" :\n");
-            appendStackTrace(bldr, ex, "\t");
+            b.append("  ComposedException ").append(i).append(" :\n");
+            appendStackTrace(b, ex, "\t");
             i++;
         }
         synchronized (s.lock()) {
-            s.println(bldr.toString());
+            s.println(b.toString());
         }
     }
 
-    private void appendStackTrace(StringBuilder bldr, Throwable ex, String prefix) {
-        bldr.append(prefix).append(ex).append('\n');
+    private void appendStackTrace(StringBuilder b, Throwable ex, String prefix) {
+        b.append(prefix).append(ex).append('\n');
         for (StackTraceElement stackElement : ex.getStackTrace()) {
-            bldr.append("\t\tat ").append(stackElement).append('\n');
+            b.append("\t\tat ").append(stackElement).append('\n');
         }
         if (ex.getCause() != null) {
-            bldr.append("\tCaused by: ");
-            appendStackTrace(bldr, ex.getCause(), "");
+            b.append("\tCaused by: ");
+            appendStackTrace(b, ex.getCause(), "");
         }
     }
 
@@ -295,10 +301,10 @@ private List<Throwable> getListOfCauses(Throwable ex) {
     }
 
     /**
-     * Returns the root cause of {@code e}. If {@code e.getCause()} returns {@null} or {@code e}, just return {@code e} itself.
+     * Returns the root cause of {@code e}. If {@code e.getCause()} returns {@code null} or {@code e}, just return {@code e} itself.
      *
      * @param e the {@link Throwable} {@code e}.
-     * @return The root cause of {@code e}. If {@code e.getCause()} returns {@null} or {@code e}, just return {@code e} itself.
+     * @return The root cause of {@code e}. If {@code e.getCause()} returns {@code null} or {@code e}, just return {@code e} itself.
      */
     private Throwable getRootCause(Throwable e) {
         Throwable root = e.getCause();
diff --git a/src/main/java/rx/exceptions/Exceptions.java b/src/main/java/rx/exceptions/Exceptions.java
index d20212cb0a..276e563e48 100644
--- a/src/main/java/rx/exceptions/Exceptions.java
+++ b/src/main/java/rx/exceptions/Exceptions.java
@@ -19,7 +19,7 @@
 
 import rx.Observer;
 import rx.SingleSubscriber;
-import rx.annotations.Experimental;
+import rx.annotations.Beta;
 
 /**
  * Utility class with methods to wrap checked exceptions and
@@ -184,7 +184,7 @@ public static void throwIfAny(List<? extends Throwable> exceptions) {
      * @param value the value that caused the exception
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static void throwOrReport(Throwable t, Observer<?> o, Object value) {
         Exceptions.throwIfFatal(t);
         o.onError(OnErrorThrowable.addValueAsLastCause(t, value));
@@ -198,7 +198,7 @@ public static void throwOrReport(Throwable t, Observer<?> o, Object value) {
      * @param value the value that caused the exception
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static void throwOrReport(Throwable t, SingleSubscriber<?> o, Object value) {
         Exceptions.throwIfFatal(t);
         o.onError(OnErrorThrowable.addValueAsLastCause(t, value));
@@ -210,7 +210,7 @@ public static void throwOrReport(Throwable t, SingleSubscriber<?> o, Object valu
      * @param o the observer to report to
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public static void throwOrReport(Throwable t, Observer<?> o) {
         Exceptions.throwIfFatal(t);
         o.onError(t);
@@ -223,7 +223,7 @@ public static void throwOrReport(Throwable t, Observer<?> o) {
      * @param subscriber the subscriber to report to.
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number).
      */
-    @Experimental
+    @Beta
     public static void throwOrReport(Throwable throwable, SingleSubscriber<?> subscriber) {
         Exceptions.throwIfFatal(throwable);
         subscriber.onError(throwable);
diff --git a/src/main/java/rx/exceptions/OnErrorThrowable.java b/src/main/java/rx/exceptions/OnErrorThrowable.java
index f49a2c8c47..77c255a874 100644
--- a/src/main/java/rx/exceptions/OnErrorThrowable.java
+++ b/src/main/java/rx/exceptions/OnErrorThrowable.java
@@ -168,14 +168,14 @@ public Object getValue() {
          *
          * If a specific behavior has been defined in the {@link RxJavaErrorHandler} plugin, some types
          * may also have a specific rendering. Non-primitive types not managed by the plugin are rendered
-         * as the classname of the object.
+         * as the class name of the object.
          * <p>
          * See PR #1401 and Issue #2468 for details.
          *
          * @param value
          *        the item that the Observable was trying to emit at the time of the exception
          * @return a string version of the object if primitive or managed through error plugin,
-         *        otherwise the classname of the object
+         *        otherwise the class name of the object
          */
         static String renderValue(Object value){
             if (value == null) {
diff --git a/src/main/java/rx/internal/operators/BackpressureUtils.java b/src/main/java/rx/internal/operators/BackpressureUtils.java
index 7f3cc0123c..11cb441efa 100644
--- a/src/main/java/rx/internal/operators/BackpressureUtils.java
+++ b/src/main/java/rx/internal/operators/BackpressureUtils.java
@@ -40,33 +40,6 @@ public final class BackpressureUtils {
     private BackpressureUtils() {
         throw new IllegalStateException("No instances!");
     }
-    /**
-     * Adds {@code n} to {@code requested} field and returns the value prior to
-     * addition once the addition is successful (uses CAS semantics). If
-     * overflows then sets {@code requested} field to {@code Long.MAX_VALUE}.
-     *
-     * @param <T> the type of the target object on which the field updater operates
-     *
-     * @param requested
-     *            atomic field updater for a request count
-     * @param object
-     *            contains the field updated by the updater
-     * @param n
-     *            the number of requests to add to the requested count
-     * @return requested value just prior to successful addition
-     * @deprecated Android has issues with reflection-based atomics
-     */
-    @Deprecated
-    public static <T> long getAndAddRequest(AtomicLongFieldUpdater<T> requested, T object, long n) {
-        // add n to field but check for overflow
-        while (true) {
-            long current = requested.get(object);
-            long next = addCap(current, n);
-            if (requested.compareAndSet(object, current, next)) {
-                return current;
-            }
-        }
-    }
 
     /**
      * Adds {@code n} (not validated) to {@code requested} and returns the value prior to addition once the
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
index 3c2e5cef7a..0e5097f78a 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorLatest.java
@@ -61,12 +61,12 @@ static final class LatestObserverIterator<T> extends Subscriber<Notification<? e
         // observer's notification
         final AtomicReference<Notification<? extends T>> value = new AtomicReference<Notification<? extends T>>();
         // iterator's notification
-        Notification<? extends T> iNotif;
+        Notification<? extends T> iteratorNotification;
 
         @Override
         public void onNext(Notification<? extends T> args) {
-            boolean wasntAvailable = value.getAndSet(args) == null;
-            if (wasntAvailable) {
+            boolean wasNotAvailable = value.getAndSet(args) == null;
+            if (wasNotAvailable) {
                 notify.release();
             }
         }
@@ -83,36 +83,36 @@ public void onCompleted() {
 
         @Override
         public boolean hasNext() {
-            if (iNotif != null && iNotif.isOnError()) {
-                throw Exceptions.propagate(iNotif.getThrowable());
+            if (iteratorNotification != null && iteratorNotification.isOnError()) {
+                throw Exceptions.propagate(iteratorNotification.getThrowable());
             }
-            if (iNotif == null || !iNotif.isOnCompleted()) {
-                if (iNotif == null) {
+            if (iteratorNotification == null || !iteratorNotification.isOnCompleted()) {
+                if (iteratorNotification == null) {
                     try {
                         notify.acquire();
                     } catch (InterruptedException ex) {
                         unsubscribe();
                         Thread.currentThread().interrupt();
-                        iNotif = Notification.createOnError(ex);
+                        iteratorNotification = Notification.createOnError(ex);
                         throw Exceptions.propagate(ex);
                     }
 
                     Notification<? extends T> n = value.getAndSet(null);
-                    iNotif = n;
-                    if (iNotif.isOnError()) {
-                        throw Exceptions.propagate(iNotif.getThrowable());
+                    iteratorNotification = n;
+                    if (iteratorNotification.isOnError()) {
+                        throw Exceptions.propagate(iteratorNotification.getThrowable());
                     }
                 }
             }
-            return !iNotif.isOnCompleted();
+            return !iteratorNotification.isOnCompleted();
         }
 
         @Override
         public T next() {
             if (hasNext()) {
-                if (iNotif.isOnNext()) {
-                    T v = iNotif.getValue();
-                    iNotif = null;
+                if (iteratorNotification.isOnNext()) {
+                    T v = iteratorNotification.getValue();
+                    iteratorNotification = null;
                     return v;
                 }
             }
diff --git a/src/main/java/rx/internal/operators/BlockingOperatorNext.java b/src/main/java/rx/internal/operators/BlockingOperatorNext.java
index 71e789df4f..e9935dafee 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorNext.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorNext.java
@@ -53,7 +53,7 @@ public Iterator<T> iterator() {
 
     }
 
-    // test needs to access the observer.waiting flag non-blockingly.
+    // test needs to access the observer.waiting flag in a non-blocking fashion.
     /* private */static final class NextIterator<T> implements Iterator<T> {
 
         private final NextObserver<T> observer;
@@ -81,11 +81,8 @@ public boolean hasNext() {
                 // the iterator has reached the end.
                 return false;
             }
-            if (!isNextConsumed) {
-                // next has not been used yet.
-                return true;
-            }
-            return moveToNext();
+            // next has not been used yet.
+            return !isNextConsumed || moveToNext();
         }
 
         @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/operators/CachedObservable.java b/src/main/java/rx/internal/operators/CachedObservable.java
index 4f5cff5b04..6f1f7598a2 100644
--- a/src/main/java/rx/internal/operators/CachedObservable.java
+++ b/src/main/java/rx/internal/operators/CachedObservable.java
@@ -63,8 +63,8 @@ public static <T> CachedObservable<T> from(Observable<? extends T> source, int c
     /**
      * Private constructor because state needs to be shared between the Observable body and
      * the onSubscribe function.
-     * @param onSubscribe
-     * @param state
+     * @param onSubscribe the shared OnSubscribe implementation
+     * @param state the cache state object
      */
     private CachedObservable(OnSubscribe<T> onSubscribe, CacheState<T> state) {
         super(onSubscribe);
@@ -81,7 +81,7 @@ private CachedObservable(OnSubscribe<T> onSubscribe, CacheState<T> state) {
 
     /**
      * Returns true if there are observers subscribed to this observable.
-     * @return
+     * @return true if this CachedObservable has observers
      */
     /* public */ boolean hasObservers() {
         return state.producers.length != 0;
@@ -121,7 +121,7 @@ public CacheState(Observable<? extends T> source, int capacityHint) {
         }
         /**
          * Adds a ReplayProducer to the producers array atomically.
-         * @param p
+         * @param p the downstream consumer's associated Producer instance
          */
         public void addProducer(ReplayProducer<T> p) {
             // guarding by connection to save on allocating another object
@@ -137,7 +137,7 @@ public void addProducer(ReplayProducer<T> p) {
         }
         /**
          * Removes the ReplayProducer (if present) from the producers array atomically.
-         * @param p
+         * @param p the downstream consumer's associated Producer instance
          */
         public void removeProducer(ReplayProducer<T> p) {
             synchronized (connection) {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeAmb.java b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
index 68d4744efe..d64567b340 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeAmb.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
@@ -294,26 +294,23 @@ private void requestMore(long n) {
 
         @Override
         public void onNext(T t) {
-            if (!isSelected()) {
-                return;
+            if (isSelected()) {
+                subscriber.onNext(t);
             }
-            subscriber.onNext(t);
         }
 
         @Override
         public void onCompleted() {
-            if (!isSelected()) {
-                return;
+            if (isSelected()) {
+                subscriber.onCompleted();
             }
-            subscriber.onCompleted();
         }
 
         @Override
         public void onError(Throwable e) {
-            if (!isSelected()) {
-                return;
+            if (isSelected()) {
+                subscriber.onError(e);
             }
-            subscriber.onError(e);
         }
 
         private boolean isSelected() {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
index 26b5390c13..f426a970d1 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
@@ -194,15 +194,14 @@ void drain() {
                         boolean b;
 
                         try {
-                            Iterable<? extends R> iter = mapper.call(nl.getValue(v));
+                            Iterable<? extends R> iterable = mapper.call(nl.getValue(v));
 
-                            it = iter.iterator();
+                            it = iterable.iterator();
 
                             b = it.hasNext();
                         } catch (Throwable ex) {
                             Exceptions.throwIfFatal(ex);
 
-                            it = null;
                             onError(ex);
 
                             continue;
@@ -316,7 +315,7 @@ boolean checkTerminated(boolean d, boolean empty, Subscriber<?> a, Queue<?> q) {
     }
 
     /**
-     * A custom flattener that works from a scalar value and computes the iterable
+     * A custom flattening operator that works from a scalar value and computes the iterable
      * during subscription time.
      *
      * @param <T> the scalar's value type
@@ -334,14 +333,14 @@ public OnSubscribeScalarFlattenIterable(T value, Func1<? super T, ? extends Iter
 
         @Override
         public void call(Subscriber<? super R> t) {
-            Iterator<? extends R> itor;
+            Iterator<? extends R> iterator;
             boolean b;
             try {
                 Iterable<? extends R> it = mapper.call(value);
 
-                itor = it.iterator();
+                iterator = it.iterator();
 
-                b = itor.hasNext();
+                b = iterator.hasNext();
             } catch (Throwable ex) {
                 Exceptions.throwOrReport(ex, t, value);
                 return;
@@ -352,7 +351,7 @@ public void call(Subscriber<? super R> t) {
                 return;
             }
 
-            t.setProducer(new OnSubscribeFromIterable.IterableProducer<R>(t, itor));
+            t.setProducer(new OnSubscribeFromIterable.IterableProducer<R>(t, iterator));
         }
     }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java b/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
index 9bc9f31a9e..4dd0c6ba51 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java
@@ -83,15 +83,15 @@ public void request(long n) {
                 return;
             }
             if (n == Long.MAX_VALUE && compareAndSet(0, Long.MAX_VALUE)) {
-                fastpath();
+                fastPath();
             } else
             if (n > 0 && BackpressureUtils.getAndAddRequest(this, n) == 0L) {
-                slowpath(n);
+                slowPath(n);
             }
 
         }
 
-        void slowpath(long n) {
+        void slowPath(long n) {
             // backpressure is requested
             final Subscriber<? super T> o = this.o;
             final Iterator<? extends T> it = this.it;
@@ -151,7 +151,7 @@ void slowpath(long n) {
 
         }
 
-        void fastpath() {
+        void fastPath() {
             // fast-path without backpressure
             final Subscriber<? super T> o = this.o;
             final Iterator<? extends T> it = this.it;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
index d3a859b7c3..fab72b9833 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssembly.java
@@ -44,11 +44,11 @@ public OnSubscribeOnAssembly(OnSubscribe<T> source) {
     }
 
     static String createStacktrace() {
-        StackTraceElement[] stes = Thread.currentThread().getStackTrace();
+        StackTraceElement[] stacktraceElements = Thread.currentThread().getStackTrace();
 
         StringBuilder sb = new StringBuilder("Assembly trace:");
 
-        for (StackTraceElement e : stes) {
+        for (StackTraceElement e : stacktraceElements) {
             String row = e.toString();
             if (!fullStackTrace) {
                 if (e.getLineNumber() <= 1) {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
index 8d78b6dbde..49e583f093 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeOnAssemblyCompletable.java
@@ -16,7 +16,6 @@
 package rx.internal.operators;
 
 import rx.*;
-import rx.CompletableSubscriber;
 import rx.exceptions.AssemblyStackTraceException;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeRange.java b/src/main/java/rx/internal/operators/OnSubscribeRange.java
index 4268917ef3..6a97a7032a 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRange.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRange.java
@@ -21,7 +21,7 @@
 import rx.Observable.OnSubscribe;
 
 /**
- * Emit ints from start to end inclusive.
+ * Emit integers from start to end inclusive.
  */
 public final class OnSubscribeRange implements OnSubscribe<Integer> {
 
@@ -60,12 +60,12 @@ public void request(long requestedAmount) {
             }
             if (requestedAmount == Long.MAX_VALUE && compareAndSet(0L, Long.MAX_VALUE)) {
                 // fast-path without backpressure
-                fastpath();
+                fastPath();
             } else if (requestedAmount > 0L) {
                 long c = BackpressureUtils.getAndAddRequest(this, requestedAmount);
                 if (c == 0L) {
                     // backpressure is requested
-                    slowpath(requestedAmount);
+                    slowPath(requestedAmount);
                 }
             }
         }
@@ -73,7 +73,7 @@ public void request(long requestedAmount) {
         /**
          * Emits as many values as requested or remaining from the range, whichever is smaller.
          */
-        void slowpath(long requestedAmount) {
+        void slowPath(long requestedAmount) {
             long emitted = 0L;
             long endIndex = endOfRange + 1L;
             long index = currentIndex;
@@ -118,7 +118,7 @@ void slowpath(long requestedAmount) {
         /**
          * Emits all remaining values without decrementing the requested amount.
          */
-        void fastpath() {
+        void fastPath() {
             final long endIndex = this.endOfRange + 1L;
             final Subscriber<? super Integer> childSubscriber = this.childSubscriber;
             for (long index = currentIndex; index != endIndex; index++) {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeToMap.java b/src/main/java/rx/internal/operators/OnSubscribeToMap.java
index ca35c8e951..6d72925011 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeToMap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeToMap.java
@@ -94,7 +94,7 @@ public void call(final Subscriber<? super Map<K, V>> subscriber) {
             return;
         }
         new ToMapSubscriber<T, K, V>(subscriber, map, keySelector, valueSelector)
-            .subscribeTo(source);;
+            .subscribeTo(source);
     }
 
     static final class ToMapSubscriber<T, K, V> extends DeferredScalarSubscriberSafe<T, Map<K,V>> {
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java b/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
index eb3f3c8f9f..c495513b14 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithSingleObservable.java
@@ -82,32 +82,32 @@ public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
             Exceptions.throwOrReport(t, child);
             return Subscribers.empty();
         }
-        final BufferingSubscriber bsub = new BufferingSubscriber(new SerializedSubscriber<List<T>>(child));
+        final BufferingSubscriber s = new BufferingSubscriber(new SerializedSubscriber<List<T>>(child));
 
         Subscriber<TClosing> closingSubscriber = new Subscriber<TClosing>() {
 
             @Override
             public void onNext(TClosing t) {
-                bsub.emit();
+                s.emit();
             }
 
             @Override
             public void onError(Throwable e) {
-                bsub.onError(e);
+                s.onError(e);
             }
 
             @Override
             public void onCompleted() {
-                bsub.onCompleted();
+                s.onCompleted();
             }
         };
 
         child.add(closingSubscriber);
-        child.add(bsub);
+        child.add(s);
 
         closing.unsafeSubscribe(closingSubscriber);
 
-        return bsub;
+        return s;
     }
 
     final class BufferingSubscriber extends Subscriber<T> {
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java b/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
index 405cf27c1d..cbcb2b584f 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithStartEndObservable.java
@@ -67,32 +67,32 @@ public OperatorBufferWithStartEndObservable(Observable<? extends TOpening> buffe
     @Override
     public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
 
-        final BufferingSubscriber bsub = new BufferingSubscriber(new SerializedSubscriber<List<T>>(child));
+        final BufferingSubscriber s = new BufferingSubscriber(new SerializedSubscriber<List<T>>(child));
 
         Subscriber<TOpening> openSubscriber = new Subscriber<TOpening>() {
 
             @Override
             public void onNext(TOpening t) {
-                bsub.startBuffer(t);
+                s.startBuffer(t);
             }
 
             @Override
             public void onError(Throwable e) {
-                bsub.onError(e);
+                s.onError(e);
             }
 
             @Override
             public void onCompleted() {
-                bsub.onCompleted();
+                s.onCompleted();
             }
 
         };
         child.add(openSubscriber);
-        child.add(bsub);
+        child.add(s);
 
         bufferOpening.unsafeSubscribe(openSubscriber);
 
-        return bsub;
+        return s;
     }
     final class BufferingSubscriber extends Subscriber<T> {
         final Subscriber<? super List<T>> child;
diff --git a/src/main/java/rx/internal/operators/OperatorBufferWithTime.java b/src/main/java/rx/internal/operators/OperatorBufferWithTime.java
index 8184a1fa77..a701e14799 100644
--- a/src/main/java/rx/internal/operators/OperatorBufferWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorBufferWithTime.java
@@ -73,19 +73,19 @@ public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
         SerializedSubscriber<List<T>> serialized = new SerializedSubscriber<List<T>>(child);
 
         if (timespan == timeshift) {
-            ExactSubscriber bsub = new ExactSubscriber(serialized, inner);
-            bsub.add(inner);
-            child.add(bsub);
-            bsub.scheduleExact();
-            return bsub;
+            ExactSubscriber parent = new ExactSubscriber(serialized, inner);
+            parent.add(inner);
+            child.add(parent);
+            parent.scheduleExact();
+            return parent;
         }
 
-        InexactSubscriber bsub = new InexactSubscriber(serialized, inner);
-        bsub.add(inner);
-        child.add(bsub);
-        bsub.startNewChunk();
-        bsub.scheduleChunk();
-        return bsub;
+        InexactSubscriber parent = new InexactSubscriber(serialized, inner);
+        parent.add(inner);
+        child.add(parent);
+        parent.startNewChunk();
+        parent.scheduleChunk();
+        return parent;
     }
     /** Subscriber when the buffer chunking time and length differ. */
     final class InexactSubscriber extends Subscriber<T> {
diff --git a/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java b/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java
index 310473d854..dee6acb4a1 100644
--- a/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java
+++ b/src/main/java/rx/internal/operators/OperatorDebounceWithSelector.java
@@ -39,8 +39,8 @@ public OperatorDebounceWithSelector(Func1<? super T, ? extends Observable<U>> se
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
-        final SerialSubscription ssub = new SerialSubscription();
-        child.add(ssub);
+        final SerialSubscription serial = new SerialSubscription();
+        child.add(serial);
 
         return new Subscriber<T>(child) {
             final DebounceState<T> state = new DebounceState<T>();
@@ -84,7 +84,7 @@ public void onCompleted() {
                         unsubscribe();
                     }
                 };
-                ssub.set(debounceSubscriber);
+                serial.set(debounceSubscriber);
 
                 debouncer.unsafeSubscribe(debounceSubscriber);
 
diff --git a/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java b/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
index dc8e5d59e0..1fe101525f 100644
--- a/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorDebounceWithTime.java
@@ -55,10 +55,10 @@ public OperatorDebounceWithTime(long timeout, TimeUnit unit, Scheduler scheduler
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         final Worker worker = scheduler.createWorker();
         final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
-        final SerialSubscription ssub = new SerialSubscription();
+        final SerialSubscription serial = new SerialSubscription();
 
         s.add(worker);
-        s.add(ssub);
+        s.add(serial);
 
         return new Subscriber<T>(child) {
             final DebounceState<T> state = new DebounceState<T>();
@@ -73,7 +73,7 @@ public void onStart() {
             public void onNext(final T t) {
 
                 final int index = state.next(t);
-                ssub.set(worker.schedule(new Action0() {
+                serial.set(worker.schedule(new Action0() {
                     @Override
                     public void call() {
                         state.emit(index, s, self);
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index 6b475619a5..b0f81db64c 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -48,7 +48,7 @@ public final class OperatorGroupBy<T, K, V> implements Operator<GroupedObservabl
     final Func1<? super T, ? extends V> valueSelector;
     final int bufferSize;
     final boolean delayError;
-    final Func1<Action1<K>, Map<K, Object>> mapFactory; //nullable
+    final Func1<Action1<K>, Map<K, Object>> mapFactory;
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public OperatorGroupBy(Func1<? super T, ? extends K> keySelector) {
diff --git a/src/main/java/rx/internal/operators/OperatorMerge.java b/src/main/java/rx/internal/operators/OperatorMerge.java
index 0cd46ea608..0e67131f13 100644
--- a/src/main/java/rx/internal/operators/OperatorMerge.java
+++ b/src/main/java/rx/internal/operators/OperatorMerge.java
@@ -81,7 +81,8 @@ public static <T> OperatorMerge<T> instance(boolean delayErrors) {
     /**
      * Creates a new instance of the operator with the given delayError and maxConcurrency settings.
      * @param <T> the value type
-     * @param delayErrors
+     * @param delayErrors if true, errors are delayed till all sources terminate, if false the first error will
+     *                    be emitted and all sequences unsubscribed
      * @param maxConcurrent the maximum number of concurrent subscriptions or Integer.MAX_VALUE for unlimited
      * @return the Operator instance with the given settings
      */
@@ -335,8 +336,8 @@ void removeInner(InnerSubscriber<T> inner) {
          * to both the main source and the inner subscribers,
          * we handle things in a shared manner.
          *
-         * @param subscriber
-         * @param value
+         * @param subscriber the subscriber to one of the inner Observables running
+         * @param value the value that inner Observable produced
          */
         void tryEmit(InnerSubscriber<T> subscriber, T value) {
             boolean success = false;
@@ -382,13 +383,11 @@ protected void queueScalar(InnerSubscriber<T> subscriber, T value) {
             } catch (MissingBackpressureException ex) {
                 subscriber.unsubscribe();
                 subscriber.onError(ex);
-                return;
             } catch (IllegalStateException ex) {
                 if (!subscriber.isUnsubscribed()) {
                     subscriber.unsubscribe();
                     subscriber.onError(ex);
                 }
-                return;
             }
         }
 
@@ -449,8 +448,7 @@ public void requestMore(long n) {
          * to both the main source and the inner subscribers,
          * we handle things in a shared manner.
          *
-         * @param subscriber
-         * @param value
+         * @param value the scalar value the main Observable emitted through {@code just()}
          */
         void tryEmit(T value) {
             boolean success = false;
@@ -506,7 +504,6 @@ protected void queueScalar(T value) {
             if (!q.offer(nl.next(value))) {
                 unsubscribe();
                 onError(OnErrorThrowable.addValueAsLastCause(new MissingBackpressureException(), value));
-                return;
             }
         }
 
diff --git a/src/main/java/rx/internal/operators/OperatorMulticast.java b/src/main/java/rx/internal/operators/OperatorMulticast.java
index dfed4b49cc..d07f60bf93 100644
--- a/src/main/java/rx/internal/operators/OperatorMulticast.java
+++ b/src/main/java/rx/internal/operators/OperatorMulticast.java
@@ -86,7 +86,7 @@ public void connect(Action1<? super Subscription> connection) {
             } else {
                 // we aren't connected, so let's create a new Subject and connect
                 final Subject<? super T, ? extends R> subject = subjectFactory.call();
-                // create new Subscriber that will pass-thru to the subject we just created
+                // create new Subscriber that will pass-through to the subject we just created
                 // we do this since it is also a Subscription whereas the Subject is not
                 subscription = Subscribers.from(subject);
                 final AtomicReference<Subscription> gs = new AtomicReference<Subscription>();
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
index 1cea49ef48..6c8770dd04 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
@@ -104,7 +104,6 @@ public void onNext(T t) {
                             onDrop.call(t);
                         } catch (Throwable e) {
                             Exceptions.throwOrReport(e, this, t);
-                            return;
                         }
                     }
                 }
diff --git a/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java b/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
index 4a3b941447..9fd7d3228b 100644
--- a/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
+++ b/src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java
@@ -84,7 +84,7 @@ public OperatorOnErrorResumeNextViaFunction(Func1<? super Throwable, ? extends O
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         final ProducerArbiter pa = new ProducerArbiter();
 
-        final SerialSubscription ssub = new SerialSubscription();
+        final SerialSubscription serial = new SerialSubscription();
 
         Subscriber<T> parent = new Subscriber<T>() {
 
@@ -130,7 +130,7 @@ public void setProducer(Producer producer) {
                             pa.setProducer(producer);
                         }
                     };
-                    ssub.set(next);
+                    serial.set(next);
 
                     long p = produced;
                     if (p != 0L) {
@@ -160,9 +160,9 @@ public void setProducer(final Producer producer) {
             }
 
         };
-        ssub.set(parent);
+        serial.set(parent);
 
-        child.add(ssub);
+        child.add(serial);
         child.setProducer(pa);
 
         return parent;
diff --git a/src/main/java/rx/internal/operators/OperatorPublish.java b/src/main/java/rx/internal/operators/OperatorPublish.java
index bc7000baa6..29ebd80149 100644
--- a/src/main/java/rx/internal/operators/OperatorPublish.java
+++ b/src/main/java/rx/internal/operators/OperatorPublish.java
@@ -76,40 +76,39 @@ public void call(Subscriber<? super T> child) {
                      * Try adding it to the current subscriber-to-source, add is atomic in respect
                      * to other adds and the termination of the subscriber-to-source.
                      */
-                    if (!r.add(inner)) {
-                        /*
-                         * The current PublishSubscriber has been terminated, try with a newer one.
-                         */
-                        continue;
-                        /*
-                         * Note: although technically correct, concurrent disconnects can cause
-                         * unexpected behavior such as child subscribers never receiving anything
-                         * (unless connected again). An alternative approach, similar to
-                         * PublishSubject would be to immediately terminate such child
-                         * subscribers as well:
-                         *
-                         * Object term = r.terminalEvent;
-                         * if (r.nl.isCompleted(term)) {
-                         *     child.onCompleted();
-                         * } else {
-                         *     child.onError(r.nl.getError(term));
-                         * }
-                         * return;
-                         *
-                         * The original concurrent behavior was non-deterministic in this regard as well.
-                         * Allowing this behavior, however, may introduce another unexpected behavior:
-                         * after disconnecting a previous connection, one might not be able to prepare
-                         * a new connection right after a previous termination by subscribing new child
-                         * subscribers asynchronously before a connect call.
-                         */
+                    if (r.add(inner)) {
+                        // the producer has been registered with the current subscriber-to-source so
+                        // at least it will receive the next terminal event
+                        child.add(inner);
+                        // setting the producer will trigger the first request to be considered by
+                        // the subscriber-to-source.
+                        child.setProducer(inner);
+                        break; // NOPMD
                     }
-                    // the producer has been registered with the current subscriber-to-source so
-                    // at least it will receive the next terminal event
-                    child.add(inner);
-                    // setting the producer will trigger the first request to be considered by
-                    // the subscriber-to-source.
-                    child.setProducer(inner);
-                    break; // NOPMD
+                    /*
+                     * The current PublishSubscriber has been terminated, try with a newer one.
+                     */
+                    /*
+                     * Note: although technically correct, concurrent disconnects can cause
+                     * unexpected behavior such as child subscribers never receiving anything
+                     * (unless connected again). An alternative approach, similar to
+                     * PublishSubject would be to immediately terminate such child
+                     * subscribers as well:
+                     *
+                     * Object term = r.terminalEvent;
+                     * if (r.nl.isCompleted(term)) {
+                     *     child.onCompleted();
+                     * } else {
+                     *     child.onError(r.nl.getError(term));
+                     * }
+                     * return;
+                     *
+                     * The original concurrent behavior was non-deterministic in this regard as well.
+                     * Allowing this behavior, however, may introduce another unexpected behavior:
+                     * after disconnecting a previous connection, one might not be able to prepare
+                     * a new connection right after a previous termination by subscribing new child
+                     * subscribers asynchronously before a connect call.
+                     */
                 }
             }
         };
@@ -171,7 +170,7 @@ private OperatorPublish(OnSubscribe<T> onSubscribe, Observable<? extends T> sour
 
     @Override
     public void connect(Action1<? super Subscription> connection) {
-        boolean doConnect = false;
+        boolean doConnect;
         PublishSubscriber<T> ps;
         // we loop because concurrent connect/disconnect and termination may change the state
         for (;;) {
diff --git a/src/main/java/rx/internal/operators/OperatorReplay.java b/src/main/java/rx/internal/operators/OperatorReplay.java
index b098304034..617656378d 100644
--- a/src/main/java/rx/internal/operators/OperatorReplay.java
+++ b/src/main/java/rx/internal/operators/OperatorReplay.java
@@ -53,7 +53,7 @@ public Object call() {
      * @param connectableFactory the factory that returns a ConnectableObservable instance
      * @param selector the function applied on the ConnectableObservable and returns the Observable
      * the downstream will subscribe to.
-     * @return the Observable multicasting over a transformation of a ConnectableObserable
+     * @return the Observable multicasting over a transformation of a ConnectableObservable
      */
     public static <T, U, R> Observable<R> multicastSelector(
             final Func0<? extends ConnectableObservable<U>> connectableFactory,
@@ -256,7 +256,7 @@ private OperatorReplay(OnSubscribe<T> onSubscribe, Observable<? extends T> sourc
 
     @Override
     public void connect(Action1<? super Subscription> connection) {
-        boolean doConnect = false;
+        boolean doConnect;
         ReplaySubscriber<T> ps;
         // we loop because concurrent connect/disconnect and termination may change the state
         for (;;) {
@@ -795,7 +795,7 @@ public void unsubscribe() {
         }
         /**
          * Convenience method to auto-cast the index object.
-         * @return
+         * @return the associated index object or null
          */
         @SuppressWarnings("unchecked")
         <U> U index() {
@@ -810,12 +810,12 @@ <U> U index() {
     interface ReplayBuffer<T> {
         /**
          * Adds a regular value to the buffer.
-         * @param value
+         * @param value the value to buffer
          */
         void next(T value);
         /**
          * Adds a terminal exception to the buffer
-         * @param e
+         * @param e the Throwable to buffer
          */
         void error(Throwable e);
         /**
@@ -827,7 +827,7 @@ interface ReplayBuffer<T> {
          * subscriber inside the output if there
          * is new value and requests available at the
          * same time.
-         * @param output
+         * @param output the producer of the downstream consumer
          */
         void replay(InnerProducer<T> output);
     }
@@ -881,8 +881,8 @@ public void replay(InnerProducer<T> output) {
                 }
                 int sourceIndex = size;
 
-                Integer destIndexObject = output.index();
-                int destIndex = destIndexObject != null ? destIndexObject : 0;
+                Integer destinationIndexObject = output.index();
+                int destinationIndex = destinationIndexObject != null ? destinationIndexObject : 0;
 
                 Subscriber<? super T> child = output.child;
                 if (child == null) {
@@ -892,8 +892,8 @@ public void replay(InnerProducer<T> output) {
                 long r = output.get();
                 long e = 0L;
 
-                while (e != r && destIndex < sourceIndex) {
-                    Object o = get(destIndex);
+                while (e != r && destinationIndex < sourceIndex) {
+                    Object o = get(destinationIndex);
                     try {
                         if (nl.accept(child, o)) {
                             return;
@@ -909,11 +909,11 @@ public void replay(InnerProducer<T> output) {
                     if (output.isUnsubscribed()) {
                         return;
                     }
-                    destIndex++;
+                    destinationIndex++;
                     e++;
                 }
                 if (e != 0L) {
-                    output.index = destIndex;
+                    output.index = destinationIndex;
                     if (r != Long.MAX_VALUE) {
                         output.produced(e);
                     }
@@ -974,7 +974,7 @@ public BoundedReplayBuffer() {
 
         /**
          * Add a new node to the linked list.
-         * @param n
+         * @param n the node to add as last
          */
         final void addLast(Node n) {
             tail.set(n);
@@ -1007,7 +1007,7 @@ final void removeFirst() {
         }
         /**
          * Arranges the given node is the new head from now on.
-         * @param n
+         * @param n the node to set as first
          */
         final void setFirst(Node n) {
             set(n);
@@ -1067,7 +1067,7 @@ public final void replay(InnerProducer<T> output) {
                     output.index = node;
 
                     /*
-                     * Since this is a latecommer, fix its total requested amount
+                     * Since this is a latecomer, fix its total requested amount
                      * as if it got all the values up to the node.index
                      */
                     output.addTotalRequested(node.index);
@@ -1134,8 +1134,8 @@ public final void replay(InnerProducer<T> output) {
         /**
          * Override this to wrap the NotificationLite object into a
          * container to be used later by truncate.
-         * @param value
-         * @return
+         * @param value the value to transform into the internal representation
+         * @return the internal representation of the value
          */
         Object enterTransform(Object value) {
             return value;
@@ -1143,8 +1143,9 @@ Object enterTransform(Object value) {
         /**
          * Override this to unwrap the transformed value into a
          * NotificationLite object.
-         * @param value
-         * @return
+         * @param value the value to transform back to external representation from
+         *              the internal representation
+         * @return the external representation of the value
          */
         Object leaveTransform(Object value) {
             return value;
diff --git a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
index 15750834fc..cef1ab9aa7 100644
--- a/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
+++ b/src/main/java/rx/internal/operators/OperatorSequenceEqual.java
@@ -28,14 +28,14 @@
 public final class OperatorSequenceEqual {
 
     /** NotificationLite doesn't work as zip uses it. */
-    static final Object LOCAL_ONCOMPLETED = new Object();
+    static final Object LOCAL_ON_COMPLETED = new Object();
 
     private OperatorSequenceEqual() {
         throw new IllegalStateException("No instances!");
     }
 
     static <T> Observable<Object> materializeLite(Observable<T> source) {
-        return concat(source, just(LOCAL_ONCOMPLETED));
+        return concat(source, just(LOCAL_ON_COMPLETED));
     }
 
     /**
@@ -65,8 +65,8 @@ public static <T> Observable<Boolean> sequenceEqual(
                     @Override
                     @SuppressWarnings("unchecked")
                     public Boolean call(Object t1, Object t2) {
-                        boolean c1 = t1 == LOCAL_ONCOMPLETED;
-                        boolean c2 = t2 == LOCAL_ONCOMPLETED;
+                        boolean c1 = t1 == LOCAL_ON_COMPLETED;
+                        boolean c2 = t2 == LOCAL_ON_COMPLETED;
                         if (c1 && c2) {
                             return true;
                         }
diff --git a/src/main/java/rx/internal/operators/OperatorSingle.java b/src/main/java/rx/internal/operators/OperatorSingle.java
index 32c752d20d..81aba32564 100644
--- a/src/main/java/rx/internal/operators/OperatorSingle.java
+++ b/src/main/java/rx/internal/operators/OperatorSingle.java
@@ -91,24 +91,21 @@ static final class ParentSubscriber<T> extends Subscriber<T> {
 
         @Override
         public void onNext(T value) {
-            if (hasTooManyElements) {
-                return;
-            } else
-            if (isNonEmpty) {
-                hasTooManyElements = true;
-                child.onError(new IllegalArgumentException("Sequence contains too many elements"));
-                unsubscribe();
-            } else {
-                this.value = value;
-                isNonEmpty = true;
+            if (!hasTooManyElements) {
+                if (isNonEmpty) {
+                    hasTooManyElements = true;
+                    child.onError(new IllegalArgumentException("Sequence contains too many elements"));
+                    unsubscribe();
+                } else {
+                    this.value = value;
+                    isNonEmpty = true;
+                }
             }
         }
 
         @Override
         public void onCompleted() {
-            if (hasTooManyElements) {
-                // We have already sent an onError message
-            } else {
+            if (!hasTooManyElements) {
                 if (isNonEmpty) {
                     child.setProducer(new SingleProducer<T>(child, value));
                 } else {
@@ -119,6 +116,7 @@ public void onCompleted() {
                     }
                 }
             }
+            // Otherwise we have already sent an onError message
         }
 
         @Override
diff --git a/src/main/java/rx/internal/operators/OperatorSwitch.java b/src/main/java/rx/internal/operators/OperatorSwitch.java
index aa640726d4..3bf96dca11 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitch.java
+++ b/src/main/java/rx/internal/operators/OperatorSwitch.java
@@ -76,7 +76,7 @@ public Subscriber<? super Observable<? extends T>> call(final Subscriber<? super
 
     static final class SwitchSubscriber<T> extends Subscriber<Observable<? extends T>> {
         final Subscriber<? super T> child;
-        final SerialSubscription ssub;
+        final SerialSubscription serial;
         final boolean delayError;
         final AtomicLong index;
         final SpscLinkedArrayQueue<Object> queue;
@@ -100,7 +100,7 @@ static final class SwitchSubscriber<T> extends Subscriber<Observable<? extends T
 
         SwitchSubscriber(Subscriber<? super T> child, boolean delayError) {
             this.child = child;
-            this.ssub = new SerialSubscription();
+            this.serial = new SerialSubscription();
             this.delayError = delayError;
             this.index = new AtomicLong();
             this.queue = new SpscLinkedArrayQueue<Object>(RxRingBuffer.SIZE);
@@ -108,7 +108,7 @@ static final class SwitchSubscriber<T> extends Subscriber<Observable<? extends T
         }
 
         void init() {
-            child.add(ssub);
+            child.add(serial);
             child.add(Subscriptions.create(new Action0() {
                 @Override
                 public void call() {
@@ -139,7 +139,7 @@ void clearProducer() {
         public void onNext(Observable<? extends T> t) {
             long id = index.incrementAndGet();
 
-            Subscription s = ssub.get();
+            Subscription s = serial.get();
             if (s != null) {
                 s.unsubscribe();
             }
@@ -152,7 +152,7 @@ public void onNext(Observable<? extends T> t) {
                 innerActive = true;
                 producer = null;
             }
-            ssub.set(inner);
+            serial.set(inner);
 
             t.unsafeSubscribe(inner);
         }
diff --git a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java b/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
index db4fb0f5ed..f3ead2c604 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
+++ b/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
@@ -35,11 +35,11 @@ public OperatorSwitchIfEmpty(Observable<? extends T> alternate) {
 
     @Override
     public Subscriber<? super T> call(Subscriber<? super T> child) {
-        final SerialSubscription ssub = new SerialSubscription();
+        final SerialSubscription serial = new SerialSubscription();
         ProducerArbiter arbiter = new ProducerArbiter();
-        final ParentSubscriber<T> parent = new ParentSubscriber<T>(child, ssub, arbiter, alternate);
-        ssub.set(parent);
-        child.add(ssub);
+        final ParentSubscriber<T> parent = new ParentSubscriber<T>(child, serial, arbiter, alternate);
+        serial.set(parent);
+        child.add(serial);
         child.setProducer(arbiter);
         return parent;
     }
@@ -48,13 +48,13 @@ static final class ParentSubscriber<T> extends Subscriber<T> {
 
         private boolean empty = true;
         private final Subscriber<? super T> child;
-        private final SerialSubscription ssub;
+        private final SerialSubscription serial;
         private final ProducerArbiter arbiter;
         private final Observable<? extends T> alternate;
 
-        ParentSubscriber(Subscriber<? super T> child, final SerialSubscription ssub, ProducerArbiter arbiter, Observable<? extends T> alternate) {
+        ParentSubscriber(Subscriber<? super T> child, final SerialSubscription serial, ProducerArbiter arbiter, Observable<? extends T> alternate) {
             this.child = child;
-            this.ssub = ssub;
+            this.serial = serial;
             this.arbiter = arbiter;
             this.alternate = alternate;
         }
@@ -75,7 +75,7 @@ public void onCompleted() {
 
         private void subscribeToAlternate() {
             AlternateSubscriber<T> as = new AlternateSubscriber<T>(child, arbiter);
-            ssub.set(as);
+            serial.set(as);
             alternate.unsafeSubscribe(as);
         }
 
diff --git a/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java b/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
index 63d4c86407..339c69c51e 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeUntilPredicate.java
@@ -60,7 +60,7 @@ final class ParentSubscriber extends Subscriber<T> {
         public void onNext(T t) {
             child.onNext(t);
 
-            boolean stop = false;
+            boolean stop;
             try {
                 stop = stopPredicate.call(t);
             } catch (Throwable e) {
diff --git a/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java b/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
index d455ba62e4..16034dba6c 100644
--- a/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
+++ b/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
@@ -44,7 +44,7 @@ public Subscription call(
                     final TimeoutSubscriber<T> timeoutSubscriber,
                     final Long seqId, Scheduler.Worker inner) {
                 if (firstTimeoutSelector != null) {
-                    Observable<U> o = null;
+                    Observable<U> o;
                     try {
                         o = firstTimeoutSelector.call();
                     } catch (Throwable t) {
@@ -79,7 +79,7 @@ public void onNext(U t) {
             public Subscription call(
                     final TimeoutSubscriber<T> timeoutSubscriber,
                     final Long seqId, T value, Scheduler.Worker inner) {
-                Observable<V> o = null;
+                Observable<V> o;
                 try {
                     o = timeoutSelector.call(value);
                 } catch (Throwable t) {
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
index 6873526940..28d44c0643 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
@@ -69,7 +69,7 @@ static final class SourceSubscriber<T, U> extends Subscriber<T> {
         /** Guarded by guard. */
         List<Object> queue;
 
-        final SerialSubscription ssub;
+        final SerialSubscription serial;
 
         final Func0<? extends Observable<? extends U>> otherFactory;
 
@@ -77,9 +77,9 @@ public SourceSubscriber(Subscriber<? super Observable<T>> child,
                 Func0<? extends Observable<? extends U>> otherFactory) {
             this.child = new SerializedSubscriber<Observable<T>>(child);
             this.guard = new Object();
-            this.ssub = new SerialSubscription();
+            this.serial = new SerialSubscription();
             this.otherFactory = otherFactory;
-            this.add(ssub);
+            this.add(serial);
         }
 
         @Override
@@ -175,7 +175,7 @@ void createNewWindow() {
             }
 
             BoundarySubscriber<T, U> bs = new BoundarySubscriber<T, U>(this);
-            ssub.set(bs);
+            serial.set(bs);
             other.unsafeSubscribe(bs);
         }
         void emitValue(T t) {
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java b/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
index bb7eb094d7..a3fce97b3f 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithStartEndObservable.java
@@ -47,10 +47,10 @@ public OperatorWindowWithStartEndObservable(Observable<? extends U> windowOpenin
 
     @Override
     public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
-        CompositeSubscription csub = new CompositeSubscription();
-        child.add(csub);
+        CompositeSubscription composite = new CompositeSubscription();
+        child.add(composite);
 
-        final SourceSubscriber sub = new SourceSubscriber(child, csub);
+        final SourceSubscriber sub = new SourceSubscriber(child, composite);
 
         Subscriber<U> open = new Subscriber<U>() {
 
@@ -75,8 +75,8 @@ public void onCompleted() {
             }
         };
 
-        csub.add(sub);
-        csub.add(open);
+        composite.add(sub);
+        composite.add(open);
 
         windowOpenings.unsafeSubscribe(open);
 
@@ -95,17 +95,17 @@ public SerializedSubject(Observer<T> consumer, Observable<T> producer) {
     }
     final class SourceSubscriber extends Subscriber<T> {
         final Subscriber<? super Observable<T>> child;
-        final CompositeSubscription csub;
+        final CompositeSubscription composite;
         final Object guard;
         /** Guarded by guard. */
         final List<SerializedSubject<T>> chunks;
         /** Guarded by guard. */
         boolean done;
-        public SourceSubscriber(Subscriber<? super Observable<T>> child, CompositeSubscription csub) {
+        public SourceSubscriber(Subscriber<? super Observable<T>> child, CompositeSubscription composite) {
             this.child = new SerializedSubscriber<Observable<T>>(child);
             this.guard = new Object();
             this.chunks = new LinkedList<SerializedSubject<T>>();
-            this.csub = csub;
+            this.composite = composite;
         }
 
         @Override
@@ -144,7 +144,7 @@ public void onError(Throwable e) {
                 }
                 child.onError(e);
             } finally {
-                csub.unsubscribe();
+                composite.unsubscribe();
             }
         }
 
@@ -165,7 +165,7 @@ public void onCompleted() {
                 }
                 child.onCompleted();
             } finally {
-                csub.unsubscribe();
+                composite.unsubscribe();
             }
         }
 
@@ -204,12 +204,12 @@ public void onCompleted() {
                     if (once) {
                         once = false;
                         endWindow(s);
-                        csub.remove(this);
+                        composite.remove(this);
                     }
                 }
 
             };
-            csub.add(v);
+            composite.add(v);
 
             end.unsafeSubscribe(v);
         }
diff --git a/src/main/java/rx/internal/operators/OperatorZip.java b/src/main/java/rx/internal/operators/OperatorZip.java
index dbc07c430b..235996c6e3 100644
--- a/src/main/java/rx/internal/operators/OperatorZip.java
+++ b/src/main/java/rx/internal/operators/OperatorZip.java
@@ -322,7 +322,7 @@ public void onNext(Object t) {
                 }
                 tick();
             }
-        };
+        }
     }
 
 }
diff --git a/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java b/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
index 67cdea7a6a..e5c5dc5ee3 100644
--- a/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
+++ b/src/main/java/rx/internal/operators/SingleOperatorOnErrorResumeNext.java
@@ -23,7 +23,7 @@
 public final class SingleOperatorOnErrorResumeNext<T> implements Single.OnSubscribe<T> {
 
     private final Single<? extends T> originalSingle;
-    private final Func1<Throwable, ? extends Single<? extends T>> resumeFunctionInCaseOfError;
+    final Func1<Throwable, ? extends Single<? extends T>> resumeFunctionInCaseOfError;
 
     private SingleOperatorOnErrorResumeNext(Single<? extends T> originalSingle, Func1<Throwable, ? extends Single<? extends T>> resumeFunctionInCaseOfError) {
         if (originalSingle == null) {
diff --git a/src/main/java/rx/internal/producers/SingleDelayedProducer.java b/src/main/java/rx/internal/producers/SingleDelayedProducer.java
index 1bc7a58e02..99e93c51ff 100644
--- a/src/main/java/rx/internal/producers/SingleDelayedProducer.java
+++ b/src/main/java/rx/internal/producers/SingleDelayedProducer.java
@@ -91,8 +91,8 @@ public void setValue(T value) {
     /**
      * Emits the given value to the child subscriber and completes it
      * and checks for unsubscriptions eagerly.
-     * @param c
-     * @param v
+     * @param c the target Subscriber to emit to
+     * @param v the value to emit
      */
     private static <T> void emit(Subscriber<? super T> c, T v) {
         if (c.isUnsubscribed()) {
diff --git a/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java b/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
index d050db1954..ed35e501e2 100644
--- a/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
+++ b/src/main/java/rx/internal/schedulers/EventLoopsScheduler.java
@@ -33,10 +33,10 @@ public final class EventLoopsScheduler extends Scheduler implements SchedulerLif
     static final int MAX_THREADS;
     static {
         int maxThreads = Integer.getInteger(KEY_MAX_THREADS, 0);
-        int ncpu = Runtime.getRuntime().availableProcessors();
+        int cpuCount = Runtime.getRuntime().availableProcessors();
         int max;
-        if (maxThreads <= 0 || maxThreads > ncpu) {
-            max = ncpu;
+        if (maxThreads <= 0 || maxThreads > cpuCount) {
+            max = cpuCount;
         } else {
             max = maxThreads;
         }
diff --git a/src/main/java/rx/internal/schedulers/ExecutorScheduler.java b/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
index ab80d476b4..82a11c1bbb 100644
--- a/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
+++ b/src/main/java/rx/internal/schedulers/ExecutorScheduler.java
@@ -141,7 +141,7 @@ public void call() {
                     if (mas.isUnsubscribed()) {
                         return;
                     }
-                    // schedule the real action untimed
+                    // schedule the real action non-delayed
                     Subscription s2 = schedule(decorated);
                     mas.set(s2);
                     // unless the worker is unsubscribed, we should get a new ScheduledAction
diff --git a/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
index 2e15c3c4a4..3d6ea1e598 100644
--- a/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
+++ b/src/main/java/rx/internal/schedulers/GenericScheduledExecutorServiceFactory.java
@@ -38,7 +38,7 @@ static ThreadFactory threadFactory() {
 
     /**
      * Creates a ScheduledExecutorService (either the default or given by a hook).
-     * @return the SchuduledExecutorService created.
+     * @return the ScheduledExecutorService created.
      */
     public static ScheduledExecutorService create() {
         Func0<? extends ScheduledExecutorService> f = RxJavaHooks.getOnGenericScheduledExecutorService();
diff --git a/src/main/java/rx/internal/schedulers/ImmediateScheduler.java b/src/main/java/rx/internal/schedulers/ImmediateScheduler.java
index 7b0b2df045..800087f2ab 100644
--- a/src/main/java/rx/internal/schedulers/ImmediateScheduler.java
+++ b/src/main/java/rx/internal/schedulers/ImmediateScheduler.java
@@ -38,10 +38,13 @@ public Worker createWorker() {
         return new InnerImmediateScheduler();
     }
 
-    private class InnerImmediateScheduler extends Scheduler.Worker implements Subscription {
+    final class InnerImmediateScheduler extends Scheduler.Worker implements Subscription {
 
         final BooleanSubscription innerSubscription = new BooleanSubscription();
 
+        InnerImmediateScheduler() {
+        }
+
         @Override
         public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
             // since we are executing immediately on this thread we must cause this thread to sleep
diff --git a/src/main/java/rx/internal/schedulers/NewThreadWorker.java b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
index b8d8d0e90d..dd63eddf9a 100644
--- a/src/main/java/rx/internal/schedulers/NewThreadWorker.java
+++ b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
@@ -30,7 +30,8 @@
 import static rx.internal.util.PlatformDependent.ANDROID_API_VERSION_IS_NOT_ANDROID;
 
 /**
- * @warn class description missing
+ * Represents a Scheduler.Worker that runs on its own unique and single-threaded ScheduledExecutorService
+ * created via Executors.
  */
 public class NewThreadWorker extends Scheduler.Worker implements Subscription {
     private final ScheduledExecutorService executor;
@@ -132,7 +133,7 @@ static void purgeExecutors() {
      * <p>{@code public} visibility reason: called from other package(s) within RxJava.
      * If the method returns false, the {@link #registerExecutor(ScheduledThreadPoolExecutor)} may
      * be called to enable the backup option of purging the executors.
-     * @param executor the executor to call setRemoveOnCaneclPolicy if available.
+     * @param executor the executor to call setRemoveOnCancelPolicy if available.
      * @return true if the policy was successfully enabled
      */
     public static boolean tryEnableCancelPolicy(ScheduledExecutorService executor) {
diff --git a/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java b/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java
index 3077ec419b..80453789da 100644
--- a/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java
+++ b/src/main/java/rx/internal/schedulers/SchedulerLifecycle.java
@@ -24,13 +24,13 @@ public interface SchedulerLifecycle {
     /**
      * Allows the Scheduler instance to start threads
      * and accept tasks on them.
-     * <p>Implementations should make sure the call is idempotent and threadsafe.
+     * <p>Implementations should make sure the call is idempotent and thread-safe.
      */
     void start();
     /**
      * Instructs the Scheduler instance to stop threads
      * and stop accepting tasks on any outstanding Workers.
-     * <p>Implementations should make sure the call is idempotent and threadsafe.
+     * <p>Implementations should make sure the call is idempotent and thread-safe.
      */
     void shutdown();
 }
\ No newline at end of file
diff --git a/src/main/java/rx/internal/schedulers/SchedulerWhen.java b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
index 4363d76da0..db1006f885 100644
--- a/src/main/java/rx/internal/schedulers/SchedulerWhen.java
+++ b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
@@ -62,7 +62,7 @@
  * thread pool:
  *
  * <pre>
- * Scheduler limitSched = Schedulers.computation().when(workers -> {
+ * Scheduler limitScheduler = Schedulers.computation().when(workers -> {
  * 	// use merge max concurrent to limit the number of concurrent
  * 	// callbacks two at a time
  * 	return Completable.merge(Observable.merge(workers), 2);
@@ -80,7 +80,7 @@
  * to the second.
  *
  * <pre>
- * Scheduler limitSched = Schedulers.computation().when(workers -> {
+ * Scheduler limitScheduler = Schedulers.computation().when(workers -> {
  * 	// use merge max concurrent to limit the number of concurrent
  * 	// Observables two at a time
  * 	return Completable.merge(Observable.merge(workers, 2));
@@ -93,7 +93,7 @@
  * algorithm).
  *
  * <pre>
- * Scheduler slowSched = Schedulers.computation().when(workers -> {
+ * Scheduler slowScheduler = Schedulers.computation().when(workers -> {
  * 	// use concatenate to make each worker happen one at a time.
  * 	return Completable.concat(workers.map(actions -> {
  * 		// delay the starting of the next worker by 1 second.
@@ -193,7 +193,7 @@ public Subscription schedule(final Action0 action) {
 		return worker;
 	}
 
-	private static final Subscription SUBSCRIBED = new Subscription() {
+	static final Subscription SUBSCRIBED = new Subscription() {
 		@Override
 		public void unsubscribe() {
 		}
@@ -204,7 +204,7 @@ public boolean isUnsubscribed() {
 		}
 	};
 
-	private static final Subscription UNSUBSCRIBED = Subscriptions.unsubscribed();
+	static final Subscription UNSUBSCRIBED = Subscriptions.unsubscribed();
 
 	@SuppressWarnings("serial")
 	private static abstract class ScheduledAction extends AtomicReference<Subscription> implements Subscription {
@@ -212,7 +212,7 @@ public ScheduledAction() {
 			super(SUBSCRIBED);
 		}
 
-		private final void call(Worker actualWorker) {
+		private void call(Worker actualWorker) {
 			Subscription oldState = get();
 			// either SUBSCRIBED or UNSUBSCRIBED
 			if (oldState == UNSUBSCRIBED) {
diff --git a/src/main/java/rx/internal/subscriptions/SequentialSubscription.java b/src/main/java/rx/internal/subscriptions/SequentialSubscription.java
index 8bd2a60a9f..4e77f42e7e 100644
--- a/src/main/java/rx/internal/subscriptions/SequentialSubscription.java
+++ b/src/main/java/rx/internal/subscriptions/SequentialSubscription.java
@@ -64,7 +64,7 @@ public Subscription current() {
      * the previous value or unsubscribes the next value if this container is unsubscribed.
      * <p>(Remark: named as such because set() is final).
      * @param next the next Subscription to contain, may be null
-     * @return true if the update succeded, false if the container was unsubscribed
+     * @return true if the update succeeded, false if the container was unsubscribed
      */
     public boolean update(Subscription next) {
         for (;;) {
@@ -91,7 +91,7 @@ public boolean update(Subscription next) {
      * does not unsubscribe the previous value or unsubscribes the next value if this
      * container is unsubscribed.
      * @param next the next Subscription to contain, may be null
-     * @return true if the update succeded, false if the container was unsubscribed
+     * @return true if the update succeeded, false if the container was unsubscribed
      */
     public boolean replace(Subscription next) {
         for (;;) {
@@ -117,7 +117,7 @@ public boolean replace(Subscription next) {
      * Unlike {@link #update(Subscription)}, this doesn't retry if the replace failed
      * because a concurrent operation changed the underlying contained object.
      * @param next the next Subscription to contain, may be null
-     * @return true if the update succeded, false if the container was unsubscribed
+     * @return true if the update succeeded, false if the container was unsubscribed
      */
     public boolean updateWeak(Subscription next) {
         Subscription current = get();
@@ -147,7 +147,7 @@ public boolean updateWeak(Subscription next) {
      * Unlike {@link #replace(Subscription)}, this doesn't retry if the replace failed
      * because a concurrent operation changed the underlying contained object.
      * @param next the next Subscription to contain, may be null
-     * @return true if the update succeded, false if the container was unsubscribed
+     * @return true if the update succeeded, false if the container was unsubscribed
      */
     public boolean replaceWeak(Subscription next) {
         Subscription current = get();
diff --git a/src/main/java/rx/internal/util/IndexedRingBuffer.java b/src/main/java/rx/internal/util/IndexedRingBuffer.java
index 8727f95be0..3699fa1d8e 100644
--- a/src/main/java/rx/internal/util/IndexedRingBuffer.java
+++ b/src/main/java/rx/internal/util/IndexedRingBuffer.java
@@ -272,7 +272,6 @@ public void releaseToPool() {
         outer: while (section != null) {
             for (int i = 0; i < SIZE; i++, realIndex++) {
                 if (realIndex >= maxIndex) {
-                    section = null;
                     break outer;
                 }
                 // we can use lazySet here because we are nulling things out and not accessing them again
@@ -385,7 +384,7 @@ private synchronized int getIndexForAdd() { // NOPMD
     /**
      * Returns -1 if nothing, 0 or greater if the index should be used
      *
-     * @return
+     * @return the index or -1 if none
      */
     private synchronized int getIndexFromPreviouslyRemoved() { // NOPMD
         /*
@@ -451,7 +450,7 @@ public int forEach(Func1<? super E, Boolean> action, int startIndex) {
     }
 
     private int forEach(Func1<? super E, Boolean> action, int startIndex, int endIndex) {
-        int lastIndex = startIndex;
+        int lastIndex;
         int maxIndex = index.get();
         int realIndex = startIndex;
         ElementSection<E> section = elements;
@@ -465,7 +464,6 @@ private int forEach(Func1<? super E, Boolean> action, int startIndex, int endInd
         outer: while (section != null) {
             for (int i = startIndex; i < SIZE; i++, realIndex++) {
                 if (realIndex >= maxIndex || realIndex >= endIndex) {
-                    section = null;
                     break outer;
                 }
                 E element = section.array.get(i);
diff --git a/src/main/java/rx/internal/util/InternalObservableUtils.java b/src/main/java/rx/internal/util/InternalObservableUtils.java
index 3aca9a0b10..93a215206c 100644
--- a/src/main/java/rx/internal/util/InternalObservableUtils.java
+++ b/src/main/java/rx/internal/util/InternalObservableUtils.java
@@ -38,7 +38,7 @@ public enum InternalObservableUtils {
     public static final PlusOneLongFunc2 LONG_COUNTER = new PlusOneLongFunc2();
 
     /**
-     * A bifunction comparing two objects via null-safe equals.
+     * A two-argument function comparing two objects via null-safe equals.
      */
     public static final ObjectEqualsFunc2 OBJECT_EQUALS = new ObjectEqualsFunc2();
     /**
@@ -142,7 +142,7 @@ public Boolean call(Object t) {
      * @param notificationHandler the handler to notify with nulls
      * @return the Func1 instance
      */
-    public static final Func1<Observable<? extends Notification<?>>, Observable<?>> createRepeatDematerializer(Func1<? super Observable<? extends Void>, ? extends Observable<?>> notificationHandler) {
+    public static Func1<Observable<? extends Notification<?>>, Observable<?>> createRepeatDematerializer(Func1<? super Observable<? extends Void>, ? extends Observable<?>> notificationHandler) {
         return new RepeatNotificationDematerializer(notificationHandler);
     }
 
@@ -158,7 +158,7 @@ public RepeatNotificationDematerializer(Func1<? super Observable<? extends Void>
         public Observable<?> call(Observable<? extends Notification<?>> notifications) {
             return notificationHandler.call(notifications.map(RETURNS_VOID));
         }
-    };
+    }
 
     static final class ReturnsVoidFunc1 implements Func1<Object, Void> {
         @Override
@@ -207,7 +207,7 @@ public Observable<R> call(Observable<T> t) {
      * @param notificationHandler the handler to notify with Throwables
      * @return the Func1 instance
      */
-    public static final Func1<Observable<? extends Notification<?>>, Observable<?>> createRetryDematerializer(Func1<? super Observable<? extends Throwable>, ? extends Observable<?>> notificationHandler) {
+    public static Func1<Observable<? extends Notification<?>>, Observable<?>> createRetryDematerializer(Func1<? super Observable<? extends Throwable>, ? extends Observable<?>> notificationHandler) {
         return new RetryNotificationDematerializer(notificationHandler);
     }
 
@@ -244,7 +244,7 @@ public static <T> Func0<ConnectableObservable<T>> createReplaySupplier(final Obs
     static final class ReplaySupplierNoParams<T> implements Func0<ConnectableObservable<T>> {
         private final Observable<T> source;
 
-        private ReplaySupplierNoParams(Observable<T> source) {
+        ReplaySupplierNoParams(Observable<T> source) {
             this.source = source;
         }
 
@@ -269,7 +269,7 @@ static final class ReplaySupplierBuffer<T> implements Func0<ConnectableObservabl
         private final Observable<T> source;
         private final int bufferSize;
 
-        private ReplaySupplierBuffer(Observable<T> source, int bufferSize) {
+        ReplaySupplierBuffer(Observable<T> source, int bufferSize) {
             this.source = source;
             this.bufferSize = bufferSize;
         }
@@ -302,7 +302,7 @@ static final class ReplaySupplierBufferTime<T> implements Func0<ConnectableObser
         private final long time;
         private final Scheduler scheduler;
 
-        private ReplaySupplierBufferTime(Observable<T> source, long time, TimeUnit unit, Scheduler scheduler) {
+        ReplaySupplierBufferTime(Observable<T> source, long time, TimeUnit unit, Scheduler scheduler) {
             this.unit = unit;
             this.source = source;
             this.time = time;
@@ -340,8 +340,8 @@ static final class ReplaySupplierTime<T> implements Func0<ConnectableObservable<
         private final int bufferSize;
         private final Observable<T> source;
 
-        private ReplaySupplierTime(Observable<T> source, int bufferSize, long time, TimeUnit unit,
-                Scheduler scheduler) {
+        ReplaySupplierTime(Observable<T> source, int bufferSize, long time, TimeUnit unit,
+                           Scheduler scheduler) {
             this.time = time;
             this.unit = unit;
             this.scheduler = scheduler;
diff --git a/src/main/java/rx/internal/util/LinkedArrayList.java b/src/main/java/rx/internal/util/LinkedArrayList.java
index 28ea19435c..df7bf19d50 100644
--- a/src/main/java/rx/internal/util/LinkedArrayList.java
+++ b/src/main/java/rx/internal/util/LinkedArrayList.java
@@ -43,7 +43,7 @@ public class LinkedArrayList {
     int indexInTail;
     /**
      * Constructor with the capacity hint of each array segment.
-     * @param capacityHint
+     * @param capacityHint the hint used for pre-sizing the internal array
      */
     public LinkedArrayList(int capacityHint) {
         this.capacityHint = capacityHint;
diff --git a/src/main/java/rx/internal/util/ObjectPool.java b/src/main/java/rx/internal/util/ObjectPool.java
index 200b8ef0ef..032e1338c3 100644
--- a/src/main/java/rx/internal/util/ObjectPool.java
+++ b/src/main/java/rx/internal/util/ObjectPool.java
@@ -40,9 +40,9 @@ public ObjectPool() {
     /**
      * Creates the pool.
      *
-     * @param minIdle
+     * @param min
      *            minimum number of objects residing in the pool
-     * @param maxIdle
+     * @param max
      *            maximum number of objects residing in the pool
      * @param validationInterval
      *            time in seconds for periodical checking of minIdle / maxIdle conditions in a separate thread.
diff --git a/src/main/java/rx/internal/util/OpenHashSet.java b/src/main/java/rx/internal/util/OpenHashSet.java
index c5dfb29587..c5045ace70 100644
--- a/src/main/java/rx/internal/util/OpenHashSet.java
+++ b/src/main/java/rx/internal/util/OpenHashSet.java
@@ -201,7 +201,7 @@ public boolean isEmpty() {
     }
 
     /**
-     * Returns the raw array of values of this set, watch out for null entires.
+     * Returns the raw array of values of this set, watch out for null entries.
      * @return the raw array of values of this set
      */
     public T[] values() {
diff --git a/src/main/java/rx/internal/util/RxRingBuffer.java b/src/main/java/rx/internal/util/RxRingBuffer.java
index eddbb3e6eb..314b135d1a 100644
--- a/src/main/java/rx/internal/util/RxRingBuffer.java
+++ b/src/main/java/rx/internal/util/RxRingBuffer.java
@@ -332,7 +332,7 @@ public void unsubscribe() {
 
     /**
      *
-     * @param o
+     * @param o the value to buffer
      * @throws MissingBackpressureException
      *             if more onNext are sent than have been requested
      */
@@ -388,10 +388,7 @@ public int count() {
 
     public boolean isEmpty() {
         Queue<Object> q = queue;
-        if (q == null) {
-            return true;
-        }
-        return q.isEmpty();
+        return q == null || q.isEmpty();
     }
 
     public Object poll() {
diff --git a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
index 577b48af3f..d14269953c 100644
--- a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
+++ b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
@@ -39,7 +39,7 @@ public final class ScalarSynchronousObservable<T> extends Observable<T> {
 
     /**
      * Indicates that the Producer used by this Observable should be fully
-     * threadsafe. It is possible, but unlikely that multiple concurrent
+     * thread-safe. It is possible, but unlikely that multiple concurrent
      * requests will arrive to just().
      */
     static final boolean STRONG_MODE;
@@ -240,7 +240,7 @@ public void call(final Subscriber<? super R> child) {
 
     /**
      * This is the weak version of SingleProducer that uses plain fields
-     * to avoid reentrancy and as such is not threadsafe for concurrent
+     * to avoid re-entrant invocation and as such is not thread-safe for concurrent
      * request() calls.
      *
      * @param <T> the value type
diff --git a/src/main/java/rx/internal/util/SubscriptionList.java b/src/main/java/rx/internal/util/SubscriptionList.java
index 263cd96fc9..8408cd2549 100644
--- a/src/main/java/rx/internal/util/SubscriptionList.java
+++ b/src/main/java/rx/internal/util/SubscriptionList.java
@@ -90,7 +90,7 @@ public void add(final Subscription s) {
 
     public void remove(final Subscription s) {
         if (!unsubscribed) {
-            boolean unsubscribe = false;
+            boolean unsubscribe;
             synchronized (this) {
                 List<Subscription> subs = subscriptions;
                 if (unsubscribed || subs == null) {
diff --git a/src/main/java/rx/internal/util/SynchronizedQueue.java b/src/main/java/rx/internal/util/SynchronizedQueue.java
index fda7b70427..27ae5de7f5 100644
--- a/src/main/java/rx/internal/util/SynchronizedQueue.java
+++ b/src/main/java/rx/internal/util/SynchronizedQueue.java
@@ -140,10 +140,7 @@ public synchronized T remove() { // NOPMD
 
     @Override
     public synchronized boolean offer(T e) { // NOPMD
-        if (size > -1 && list.size() + 1 > size) {
-            return false;
-        }
-        return list.offer(e);
+        return !(size > -1 && list.size() + 1 > size) && list.offer(e);
     }
 
     @Override
diff --git a/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
index 2e3cd27052..c2b4f43eac 100644
--- a/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
@@ -315,10 +315,10 @@ public T element() {
     }
 
     /**
-     * Offer two elements at the same time.
+     * Atomically offer two elements.
      * <p>Don't use the regular offer() with this at all!
-     * @param first
-     * @param second
+     * @param first the first value
+     * @param second the second value
      * @return always true
      */
     public boolean offer(T first, T second) {
diff --git a/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java b/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
index 6b57e9cccc..7a11f99d85 100644
--- a/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
@@ -83,7 +83,7 @@ protected final long calcElementOffset(long index) {
     }
     /**
      * @param index desirable element index
-     * @param mask
+     * @param mask the binary mask to make the index wrap around
      * @return the offset in bytes within the array for a given index.
      */
     protected final long calcElementOffset(long index, long mask) {
diff --git a/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java b/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java
index 4cd0d3fc27..8d9426efb6 100644
--- a/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/MessagePassingQueue.java
@@ -35,7 +35,7 @@ public interface MessagePassingQueue<M> {
      * Called from a producer thread subject to the restrictions appropriate to the implementation and according to the
      * {@link Queue#offer(Object)} interface.
      *
-     * @param message
+     * @param message the Object to enqueue, not null
      * @return true if element was inserted into the queue, false iff full
      */
     boolean offer(M message);
diff --git a/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java b/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java
index d4a5eb2494..a69c29d923 100644
--- a/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/MpmcArrayQueue.java
@@ -83,9 +83,9 @@ protected final boolean casConsumerIndex(long expect, long newValue) {
  * algorithm uses an array of structs which should offer nice locality properties but is sadly not possible in
  * Java (waiting on Value Types or similar). The alternative explored here utilizes 2 arrays, one for each
  * field of the struct. There is a further alternative in the experimental project which uses iteration phase
- * markers to achieve the same algo and is closer structurally to the original, but sadly does not perform as
+ * markers to achieve the same algorithm and is closer structurally to the original, but sadly does not perform as
  * well as this implementation.<br>
- * Tradeoffs to keep in mind:
+ * Trade-offs to keep in mind:
  * <ol>
  * <li>Padding for false sharing: counter fields and queue fields are all padded as well as either side of
  * both arrays. We are trading memory to avoid false sharing(active and passive).
diff --git a/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java b/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
index 56b69e09d7..e6b4c350e9 100644
--- a/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
@@ -27,7 +27,7 @@
  * layout:
  * <ol>
  * <li>Use inheritance to ensure no false sharing occurs between producer/consumer node reference fields.
- * <li>Use XCHG functionality to the best of the JDK ability (see differences in JDK7/8 impls).
+ * <li>Use XCHG functionality to the best of the JDK ability (see differences in JDK7/8 implementations).
  * </ol>
  * The queue is initialized with a stub node which is set to both the producer and consumer node references. From this
  * point follow the notes on offer/poll.
diff --git a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
index ad752d365b..eab0fec910 100644
--- a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
@@ -97,7 +97,7 @@ public SpscUnboundedArrayQueue(final int bufferSize) {
         consumerBuffer = buffer;
         consumerMask = mask;
         producerLookAhead = mask - 1; // we know it's all empty to start with
-        soProducerIndex(0l);
+        soProducerIndex(0L);
     }
 
     @Override
diff --git a/src/main/java/rx/observables/BlockingObservable.java b/src/main/java/rx/observables/BlockingObservable.java
index d9fd534bf4..5a4c5944ef 100644
--- a/src/main/java/rx/observables/BlockingObservable.java
+++ b/src/main/java/rx/observables/BlockingObservable.java
@@ -22,12 +22,11 @@
 import rx.*;
 import rx.Observable;
 import rx.Observer;
-import rx.annotations.Experimental;
+import rx.annotations.Beta;
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.internal.operators.*;
-import rx.internal.util.BlockingUtils;
-import rx.internal.util.UtilityFunctions;
+import rx.internal.util.*;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -470,8 +469,9 @@ public void onNext(final T item) {
 
     /**
      * Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public void subscribe() {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] error = { null };
@@ -503,8 +503,9 @@ public void onCompleted() {
     /**
      * Subscribes to the source and calls back the Observer methods on the current thread.
      * @param observer the observer to call event methods on
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public void subscribe(Observer<? super T> observer) {
         final NotificationLite<T> nl = NotificationLite.instance();
         final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();
@@ -548,9 +549,10 @@ public void onCompleted() {
      * <p>
      * The unsubscription and backpressure is composed through.
      * @param subscriber the subscriber to forward events and calls to in the current thread
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @SuppressWarnings("unchecked")
-    @Experimental
+    @Beta
     public void subscribe(Subscriber<? super T> subscriber) {
         final NotificationLite<T> nl = NotificationLite.instance();
         final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();
@@ -631,8 +633,9 @@ public void call() {
      *
      * @param onNext the callback action for each source value
      * @see #forEach(Action1)
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public void subscribe(final Action1<? super T> onNext) {
         subscribe(onNext, new Action1<Throwable>() {
             @Override
@@ -646,8 +649,9 @@ public void call(Throwable t) {
      * Subscribes to the source and calls the given actions on the current thread.
      * @param onNext the callback action for each source value
      * @param onError the callback action for an error event
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public void subscribe(final Action1<? super T> onNext, final Action1<? super Throwable> onError) {
         subscribe(onNext, onError, Actions.empty());
     }
@@ -657,8 +661,9 @@ public void subscribe(final Action1<? super T> onNext, final Action1<? super Thr
      * @param onNext the callback action for each source value
      * @param onError the callback action for an error event
      * @param onCompleted the callback action for the completion event.
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @Experimental
+    @Beta
     public void subscribe(final Action1<? super T> onNext, final Action1<? super Throwable> onError, final Action0 onCompleted) {
         subscribe(new Observer<T>() {
             @Override
diff --git a/src/main/java/rx/observables/ConnectableObservable.java b/src/main/java/rx/observables/ConnectableObservable.java
index 7df7823d0d..09ac04257d 100644
--- a/src/main/java/rx/observables/ConnectableObservable.java
+++ b/src/main/java/rx/observables/ConnectableObservable.java
@@ -16,7 +16,6 @@
 package rx.observables;
 
 import rx.*;
-import rx.annotations.Beta;
 import rx.functions.*;
 import rx.internal.operators.*;
 
@@ -86,9 +85,8 @@ public Observable<T> refCount() {
      *
      * @return an Observable that automatically connects to this ConnectableObservable
      *         when the first Subscriber subscribes
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.2
      */
-    @Beta
     public Observable<T> autoConnect() {
         return autoConnect(1);
     }
@@ -101,9 +99,8 @@ public Observable<T> autoConnect() {
      *                            an immediate connection.
      * @return an Observable that automatically connects to this ConnectableObservable
      *         when the specified number of Subscribers subscribe to it
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.2
      */
-    @Beta
     public Observable<T> autoConnect(int numberOfSubscribers) {
         return autoConnect(numberOfSubscribers, Actions.empty());
     }
@@ -121,9 +118,8 @@ public Observable<T> autoConnect(int numberOfSubscribers) {
      * @return an Observable that automatically connects to this ConnectableObservable
      *         when the specified number of Subscribers subscribe to it and calls the
      *         specified callback with the Subscription associated with the established connection
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.2
      */
-    @Beta
     public Observable<T> autoConnect(int numberOfSubscribers, Action1<? super Subscription> connection) {
         if (numberOfSubscribers <= 0) {
             this.connect(connection);
diff --git a/src/main/java/rx/observables/SyncOnSubscribe.java b/src/main/java/rx/observables/SyncOnSubscribe.java
index bebf6fe789..6e4b887da4 100644
--- a/src/main/java/rx/observables/SyncOnSubscribe.java
+++ b/src/main/java/rx/observables/SyncOnSubscribe.java
@@ -38,8 +38,8 @@
  *            {@link #onUnsubscribe(Object) onUnsubscribe(S)}.
  * @param <T>
  *            the type of {@code Subscribers} that will be compatible with {@code this}.
+ * @since 1.2
  */
-@Beta
 public abstract class SyncOnSubscribe<S, T> implements OnSubscribe<T> {
 
     /* (non-Javadoc)
@@ -359,7 +359,7 @@ public void unsubscribe() {
                 else if (compareAndSet(requestCount, -2L)) {
                     // the loop is iterating concurrently
                     // need to check if requestCount == -1
-                    // and unsub if so after loop iteration
+                    // and unsubscribe if so after loop iteration
                     return;
                 }
             }
@@ -390,14 +390,14 @@ private void doUnsubscribe() {
         public void request(long n) {
             if (n > 0 && BackpressureUtils.getAndAddRequest(this, n) == 0L) {
                 if (n == Long.MAX_VALUE) {
-                    fastpath();
+                    fastPath();
                 } else {
                     slowPath(n);
                 }
             }
         }
 
-        private void fastpath() {
+        private void fastPath() {
             final SyncOnSubscribe<S, T> p = parent;
             Subscriber<? super T> a = actualSubscriber;
 
diff --git a/src/main/java/rx/observers/AsyncCompletableSubscriber.java b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
index 2aa9421de1..28c346da76 100644
--- a/src/main/java/rx/observers/AsyncCompletableSubscriber.java
+++ b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
@@ -26,7 +26,7 @@
  * An abstract base class for CompletableSubscriber implementations that want to expose an unsubscription
  * capability.
  * <p>
- * Calling {@link #unsubscribe()} and {@link #isUnsubscribed()} is threadsafe and can happen at any time, even
+ * Calling {@link #unsubscribe()} and {@link #isUnsubscribed()} is thread-safe and can happen at any time, even
  * before or during an active {@link rx.Completable#subscribe(CompletableSubscriber)} call.
  * <p>
  * Override the {@link #onStart()} method to execute custom logic on the very first successful onSubscribe call.
diff --git a/src/main/java/rx/observers/TestObserver.java b/src/main/java/rx/observers/TestObserver.java
index bcfc5f9131..dfe5dcad38 100644
--- a/src/main/java/rx/observers/TestObserver.java
+++ b/src/main/java/rx/observers/TestObserver.java
@@ -24,7 +24,7 @@
 /**
  * Observer usable for unit testing to perform assertions, inspect received events or wrap a mocked Observer.
  * @param <T> the observed value type
- * @deprecated use the {@link TestSubscriber} insteand.
+ * @deprecated use the {@link TestSubscriber} instead.
  */
 @Deprecated
 public class TestObserver<T> implements Observer<T> {
diff --git a/src/main/java/rx/plugins/RxJavaErrorHandler.java b/src/main/java/rx/plugins/RxJavaErrorHandler.java
index a84526e1ef..9324cb9062 100644
--- a/src/main/java/rx/plugins/RxJavaErrorHandler.java
+++ b/src/main/java/rx/plugins/RxJavaErrorHandler.java
@@ -57,7 +57,7 @@ public void handleError(Throwable e) {
      * <p>
      * Note that primitive types are always rendered as their {@code toString()} value.
      * <p>
-     * If a {@code Throwable} is caught when rendering, this will fallback to the item's classname suffixed by
+     * If a {@code Throwable} is caught when rendering, this will fallback to the item's class name suffixed by
      * {@code ERROR_IN_RENDERING_SUFFIX}.
      *
      * @param item the last emitted item, that caused the exception wrapped in
@@ -87,7 +87,7 @@ public final String handleOnNextValueRendering(Object item) {
      * {@code String} (as large renderings will bloat up the stacktrace). Prefer to try/catch({@code Throwable})
      * all code inside this method implementation.
      * <p>
-     * If a {@code Throwable} is caught when rendering, this will fallback to the item's classname suffixed by
+     * If a {@code Throwable} is caught when rendering, this will fallback to the item's class name suffixed by
      * {@value #ERROR_IN_RENDERING_SUFFIX}.
      *
      * @param item the last emitted item, that caused the exception wrapped in
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index ede280a1dc..159da16771 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -235,7 +235,7 @@ public static void reset() {
     }
 
     /**
-     * Clears all hooks to be no-operations (and passthroughs)
+     * Clears all hooks to be no-op (and pass-through)
      * and onError hook to signal errors to the caller thread's
      * UncaughtExceptionHandler.
      *
@@ -576,7 +576,7 @@ public static <T, R> Completable.Operator onCompletableLift(Completable.Operator
     /**
      * Sets the global error consumer action unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter has the effect that
      * errors are routed to the current thread's {@link UncaughtExceptionHandler}.
@@ -592,7 +592,7 @@ public static void setOnError(Action1<Throwable> onError) {
     /**
      * Sets the Completable's onCreate hook function unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -610,7 +610,7 @@ public static void setOnCompletableCreate(
     /**
      * Sets the Observable onCreate hook function unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -629,7 +629,7 @@ public static void setOnObservableCreate(
     /**
      * Sets the Single onCreate hook function unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -648,7 +648,7 @@ public static void setOnSingleCreate(Func1<Single.OnSubscribe, Single.OnSubscrib
      * Sets the hook function for returning a scheduler when the Schedulers.computation() is called
      * unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -666,7 +666,7 @@ public static void setOnComputationScheduler(Func1<Scheduler, Scheduler> onCompu
      * Sets the hook function for returning a scheduler when the Schedulers.io() is called
      * unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -684,7 +684,7 @@ public static void setOnIOScheduler(Func1<Scheduler, Scheduler> onIOScheduler) {
      * Sets the hook function for returning a scheduler when the Schedulers.newThread() is called
      * unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -702,7 +702,7 @@ public static void setOnNewThreadScheduler(Func1<Scheduler, Scheduler> onNewThre
      * Sets the hook function that is called before an action is scheduled, allowing
      * decorating that function, unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -720,7 +720,7 @@ public static void setOnScheduleAction(Func1<Action0, Action0> onScheduleAction)
      * Sets the hook function that is called when a subscriber subscribes to a Completable
      * unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same CompletableOnSubscribe object.
@@ -740,7 +740,7 @@ public static void setOnCompletableStart(
      * Sets the hook function that is called when a subscriber subscribes to a Observable
      * unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same OnSubscribe object.
@@ -761,7 +761,7 @@ public static void setOnObservableStart(
      * Sets the hook function that is called when a subscriber subscribes to a Single
      * unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same OnSubscribe object.
@@ -781,7 +781,7 @@ public static void setOnSingleStart(Func2<Single, Observable.OnSubscribe, Observ
      * Sets a hook function that is called when the Observable.subscribe() call
      * is about to return a Subscription unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -800,7 +800,7 @@ public static void setOnObservableReturn(Func1<Subscription, Subscription> onObs
      * Sets a hook function that is called when the Single.subscribe() call
      * is about to return a Subscription unless a lockdown is in effect.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -819,7 +819,7 @@ public static void setOnSingleReturn(Func1<Subscription, Subscription> onSingleR
      * Sets a hook function that is called when the Single.subscribe() call
      * fails with an exception.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -837,7 +837,7 @@ public static void setOnSingleSubscribeError(Func1<Throwable, Throwable> onSingl
      * Returns the current Single onSubscribeError hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func1<Throwable, Throwable> getOnSingleSubscribeError() {
@@ -848,7 +848,7 @@ public static Func1<Throwable, Throwable> getOnSingleSubscribeError() {
      * Sets a hook function that is called when the Completable.subscribe() call
      * fails with an exception.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -866,7 +866,7 @@ public static void setOnCompletableSubscribeError(Func1<Throwable, Throwable> on
      * Returns the current Completable onSubscribeError hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func1<Throwable, Throwable> getOnCompletableSubscribeError() {
@@ -877,7 +877,7 @@ public static Func1<Throwable, Throwable> getOnCompletableSubscribeError() {
      * Sets a hook function that is called when the Observable.subscribe() call
      * fails with an exception.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -895,7 +895,7 @@ public static void setOnObservableSubscribeError(Func1<Throwable, Throwable> onO
      * Returns the current Observable onSubscribeError hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func1<Throwable, Throwable> getOnObservableSubscribeError() {
@@ -906,7 +906,7 @@ public static Func1<Throwable, Throwable> getOnObservableSubscribeError() {
      * Sets a hook function that is called with an operator when an Observable operator built with
      * lift() gets subscribed to.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -925,7 +925,7 @@ public static void setOnObservableLift(Func1<Observable.Operator, Observable.Ope
      * Returns the current Observable onLift hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     @SuppressWarnings("rawtypes")
@@ -937,7 +937,7 @@ public static Func1<Observable.Operator, Observable.Operator> getOnObservableLif
      * Sets a hook function that is called with an operator when an Single operator built with
      * lift() gets subscribed to.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -956,7 +956,7 @@ public static void setOnSingleLift(Func1<Observable.Operator, Observable.Operato
      * Returns the current Single onLift hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     @SuppressWarnings("rawtypes")
@@ -968,7 +968,7 @@ public static Func1<Observable.Operator, Observable.Operator> getOnSingleLift()
      * Sets a hook function that is called with an operator when a Completable operator built with
      * lift() gets subscribed to.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * the hook returns the same object.
@@ -986,7 +986,7 @@ public static void setOnCompletableLift(Func1<Completable.Operator, Completable.
      * Returns the current Completable onLift hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func1<Completable.Operator, Completable.Operator> getOnCompletableLift() {
@@ -997,7 +997,7 @@ public static Func1<Completable.Operator, Completable.Operator> getOnCompletable
      * Returns the current computation scheduler hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func1<Scheduler, Scheduler> getOnComputationScheduler() {
@@ -1009,7 +1009,7 @@ public static Func1<Scheduler, Scheduler> getOnComputationScheduler() {
      * set to the default one that signals errors to the current threads
      * UncaughtExceptionHandler.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook action
      */
     public static Action1<Throwable> getOnError() {
@@ -1020,7 +1020,7 @@ public static Action1<Throwable> getOnError() {
      * Returns the current io scheduler hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func1<Scheduler, Scheduler> getOnIOScheduler() {
@@ -1031,7 +1031,7 @@ public static Func1<Scheduler, Scheduler> getOnIOScheduler() {
      * Returns the current new thread scheduler hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func1<Scheduler, Scheduler> getOnNewThreadScheduler() {
@@ -1042,7 +1042,7 @@ public static Func1<Scheduler, Scheduler> getOnNewThreadScheduler() {
      * Returns the current Observable onCreate hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     @SuppressWarnings("rawtypes")
@@ -1054,7 +1054,7 @@ public static Func1<Observable.OnSubscribe, Observable.OnSubscribe> getOnObserva
      * Returns the current schedule action hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func1<Action0, Action0> getOnScheduleAction() {
@@ -1065,7 +1065,7 @@ public static Func1<Action0, Action0> getOnScheduleAction() {
      * Returns the current Single onCreate hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     @SuppressWarnings("rawtypes")
@@ -1077,7 +1077,7 @@ public static Func1<Single.OnSubscribe, Single.OnSubscribe> getOnSingleCreate()
      * Returns the current Completable onCreate hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func1<Completable.OnSubscribe, Completable.OnSubscribe> getOnCompletableCreate() {
@@ -1088,7 +1088,7 @@ public static Func1<Completable.OnSubscribe, Completable.OnSubscribe> getOnCompl
      * Returns the current Completable onStart hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func2<Completable, Completable.OnSubscribe, Completable.OnSubscribe> getOnCompletableStart() {
@@ -1099,7 +1099,7 @@ public static Func2<Completable, Completable.OnSubscribe, Completable.OnSubscrib
      * Returns the current Observable onStart hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     @SuppressWarnings("rawtypes")
@@ -1111,7 +1111,7 @@ public static Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe>
      * Returns the current Single onStart hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     @SuppressWarnings("rawtypes")
@@ -1123,7 +1123,7 @@ public static Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> getO
      * Returns the current Observable onReturn hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func1<Subscription, Subscription> getOnObservableReturn() {
@@ -1134,7 +1134,7 @@ public static Func1<Subscription, Subscription> getOnObservableReturn() {
      * Returns the current Single onReturn hook function or null if it is
      * set to the default pass-through.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current hook function
      */
     public static Func1<Subscription, Subscription> getOnSingleReturn() {
@@ -1168,7 +1168,7 @@ public static void clearAssemblyTracking() {
     /**
      * Sets up hooks that capture the current stacktrace when a source or an
      * operator is instantiated, keeping it in a field for debugging purposes
-     * and alters exceptions passign along to hold onto this stacktrace.
+     * and alters exceptions passing along to hold onto this stacktrace.
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
     public static void enableAssemblyTracking() {
@@ -1202,7 +1202,7 @@ public Completable.OnSubscribe call(Completable.OnSubscribe f) {
      * Sets the hook function for returning a ScheduledExecutorService used
      * by the GenericScheduledExecutorService for background tasks.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * <p>
      * Calling with a {@code null} parameter restores the default behavior:
      * create the default with {@link java.util.concurrent.Executors#newScheduledThreadPool(int, java.util.concurrent.ThreadFactory)}.
@@ -1222,7 +1222,7 @@ public static void setOnGenericScheduledExecutorService(Func0<? extends Schedule
      * Returns the current factory for creating ScheduledExecutorServices in
      * GenericScheduledExecutorService utility.
      * <p>
-     * This operation is threadsafe.
+     * This operation is thread-safe.
      * @return the current factory function
      */
     public static Func0<? extends ScheduledExecutorService> getOnGenericScheduledExecutorService() {
diff --git a/src/main/java/rx/plugins/RxJavaPlugins.java b/src/main/java/rx/plugins/RxJavaPlugins.java
index f9df704304..91ba9fa1fa 100644
--- a/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -28,14 +28,14 @@
  * property names)</li>
  * <li>default implementation</li>
  * </ol>
- * <p>In addition to the {@code rxjava.plugin.[simple classname].implementation} system properties,
+ * <p>In addition to the {@code rxjava.plugin.[simple class name].implementation} system properties,
  * you can define two system property:<br>
  * <pre><code>
  * rxjava.plugin.[index].class}
  * rxjava.plugin.[index].impl}
  * </code></pre>
  *
- * Where the {@code .class} property contains the simple classname from above and the {@code .impl}
+ * Where the {@code .class} property contains the simple class name from above and the {@code .impl}
  * contains the fully qualified name of the implementation class. The {@code [index]} can be
  * any short string or number of your choosing. For example, you can now define a custom
  * {@code RxJavaErrorHandler} via two system property:
@@ -100,7 +100,7 @@ public void reset() {
      * {@link RxJavaPlugins} class header.
      * <p>
      * Override the default by calling {@link #registerErrorHandler(RxJavaErrorHandler)} or by setting the
-     * property {@code rxjava.plugin.RxJavaErrorHandler.implementation} with the full classname to load.
+     * property {@code rxjava.plugin.RxJavaErrorHandler.implementation} with the full class name to load.
      * @return {@link RxJavaErrorHandler} implementation to use
      */
     public RxJavaErrorHandler getErrorHandler() {
@@ -141,7 +141,7 @@ public void registerErrorHandler(RxJavaErrorHandler impl) {
      * <p>
      * Override the default by calling {@link #registerObservableExecutionHook(RxJavaObservableExecutionHook)}
      * or by setting the property {@code rxjava.plugin.RxJavaObservableExecutionHook.implementation} with the
-     * full classname to load.
+     * full class name to load.
      *
      * @return {@link RxJavaObservableExecutionHook} implementation to use
      */
@@ -183,7 +183,7 @@ public void registerObservableExecutionHook(RxJavaObservableExecutionHook impl)
      * <p>
      * Override the default by calling {@link #registerSingleExecutionHook(RxJavaSingleExecutionHook)}
      * or by setting the property {@code rxjava.plugin.RxJavaSingleExecutionHook.implementation} with the
-     * full classname to load.
+     * full class name to load.
      *
      * @return {@link RxJavaSingleExecutionHook} implementation to use
      */
@@ -225,7 +225,7 @@ public void registerSingleExecutionHook(RxJavaSingleExecutionHook impl) {
      * <p>
      * Override the default by calling {@link #registerCompletableExecutionHook(RxJavaCompletableExecutionHook)}
      * or by setting the property {@code rxjava.plugin.RxJavaCompletableExecutionHook.implementation} with the
-     * full classname to load.
+     * full class name to load.
      *
      * @return {@link RxJavaCompletableExecutionHook} implementation to use
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
@@ -334,7 +334,7 @@ public void registerCompletableExecutionHook(RxJavaCompletableExecutionHook impl
      * in the {@link RxJavaPlugins} class header.
      * <p>
      * Override the default by calling {@link #registerSchedulersHook(RxJavaSchedulersHook)} or by setting
-     * the property {@code rxjava.plugin.RxJavaSchedulersHook.implementation} with the full classname to
+     * the property {@code rxjava.plugin.RxJavaSchedulersHook.implementation} with the full class name to
      * load.
      *
      * @return the {@link RxJavaSchedulersHook} implementation in use
diff --git a/src/main/java/rx/schedulers/Schedulers.java b/src/main/java/rx/schedulers/Schedulers.java
index 32857181a9..502a59bcf7 100644
--- a/src/main/java/rx/schedulers/Schedulers.java
+++ b/src/main/java/rx/schedulers/Schedulers.java
@@ -176,7 +176,7 @@ public static void reset() {
 
     /**
      * Starts those standard Schedulers which support the SchedulerLifecycle interface.
-     * <p>The operation is idempotent and threadsafe.
+     * <p>The operation is idempotent and thread-safe.
      */
     public static void start() {
         Schedulers s = getInstance();
@@ -193,7 +193,7 @@ public static void start() {
     }
     /**
      * Shuts down those standard Schedulers which support the SchedulerLifecycle interface.
-     * <p>The operation is idempotent and threadsafe.
+     * <p>The operation is idempotent and thread-safe.
      */
     public static void shutdown() {
         Schedulers s = getInstance();
diff --git a/src/main/java/rx/schedulers/Timestamped.java b/src/main/java/rx/schedulers/Timestamped.java
index e05f21d226..5a3cac829d 100644
--- a/src/main/java/rx/schedulers/Timestamped.java
+++ b/src/main/java/rx/schedulers/Timestamped.java
@@ -58,10 +58,7 @@ public boolean equals(Object obj) {
             return false;
         }
         Timestamped<?> other = (Timestamped<?>) obj;
-        if (timestampMillis != other.timestampMillis) {
-            return false;
-        }
-        return (value == other.value) || (value != null && value.equals(other.value));
+        return timestampMillis == other.timestampMillis && ((value == other.value) || (value != null && value.equals(other.value)));
     }
 
     @Override
diff --git a/src/main/java/rx/singles/BlockingSingle.java b/src/main/java/rx/singles/BlockingSingle.java
index f5d9f0027f..470c012cdb 100644
--- a/src/main/java/rx/singles/BlockingSingle.java
+++ b/src/main/java/rx/singles/BlockingSingle.java
@@ -16,18 +16,15 @@
 
 package rx.singles;
 
-import rx.Single;
-import rx.SingleSubscriber;
-import rx.Subscription;
-import rx.annotations.Experimental;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicReference;
+
+import rx.*;
+import rx.annotations.*;
 import rx.exceptions.Exceptions;
 import rx.internal.operators.BlockingOperatorToFuture;
 import rx.internal.util.BlockingUtils;
 
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicReference;
-
 /**
  * {@code BlockingSingle} is a blocking "version" of {@link Single} that provides blocking
  * operators.
@@ -38,7 +35,7 @@
  * @param <T> the value type of the sequence
  * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
  */
-@Experimental
+@Beta
 public final class BlockingSingle<T> {
     private final Single<? extends T> single;
 
@@ -53,7 +50,6 @@ private BlockingSingle(Single<? extends T> single) {
      * @param single the {@link Single} you want to convert
      * @return a {@code BlockingSingle} version of {@code single}
      */
-    @Experimental
     public static <T> BlockingSingle<T> from(Single<? extends T> single) {
         return new BlockingSingle<T>(single);
     }
@@ -68,7 +64,6 @@ public static <T> BlockingSingle<T> from(Single<? extends T> single) {
      *
      * @return the value emitted by this {@code BlockingSingle}
      */
-    @Experimental
     public T value() {
         final AtomicReference<T> returnItem = new AtomicReference<T>();
         final AtomicReference<Throwable> returnException = new AtomicReference<Throwable>();
@@ -101,7 +96,6 @@ public void onError(Throwable error) {
      * @return a {@link Future} that returns the value
      */
     @SuppressWarnings("unchecked")
-    @Experimental
     public Future<T> toFuture() {
         return BlockingOperatorToFuture.toFuture(((Single<T>)single).toObservable());
     }
diff --git a/src/main/java/rx/subjects/AsyncSubject.java b/src/main/java/rx/subjects/AsyncSubject.java
index c8259c4b2c..4a1038b5ef 100644
--- a/src/main/java/rx/subjects/AsyncSubject.java
+++ b/src/main/java/rx/subjects/AsyncSubject.java
@@ -18,7 +18,6 @@
 import java.util.*;
 
 import rx.Observer;
-import rx.annotations.Beta;
 import rx.exceptions.Exceptions;
 import rx.functions.Action1;
 import rx.internal.operators.NotificationLite;
@@ -144,8 +143,8 @@ public boolean hasObservers() {
      * <p>Note that unless {@link #hasCompleted()} or {@link #hasThrowable()} returns true, the value
      * retrieved by {@code getValue()} may get outdated.
      * @return true if and only if the subject has some value but not an error
+     * @since 1.2
      */
-    @Beta
     public boolean hasValue() {
         Object v = lastValue;
         Object o = state.getLatest();
@@ -154,8 +153,8 @@ public boolean hasValue() {
     /**
      * Check if the Subject has terminated with an exception.
      * @return true if the subject has received a throwable through {@code onError}.
+     * @since 1.2
      */
-    @Beta
     public boolean hasThrowable() {
         Object o = state.getLatest();
         return nl.isError(o);
@@ -163,8 +162,8 @@ public boolean hasThrowable() {
     /**
      * Check if the Subject has terminated normally.
      * @return true if the subject completed normally via {@code onCompleted()}
+     * @since 1.2
      */
-    @Beta
     public boolean hasCompleted() {
         Object o = state.getLatest();
         return o != null && !nl.isError(o);
@@ -177,8 +176,8 @@ public boolean hasCompleted() {
      * exception or the Subject terminated without receiving any value.
      * @return the current value or {@code null} if the Subject doesn't have a value,
      * has terminated with an exception or has an actual {@code null} as a value.
+     * @since 1.2
      */
-    @Beta
     public T getValue() {
         Object v = lastValue;
         Object o = state.getLatest();
@@ -191,8 +190,8 @@ public T getValue() {
      * Returns the Throwable that terminated the Subject.
      * @return the Throwable that terminated the Subject or {@code null} if the
      * subject hasn't terminated yet or it terminated normally.
+     * @since 1.2
      */
-    @Beta
     public Throwable getThrowable() {
         Object o = state.getLatest();
         if (nl.isError(o)) {
diff --git a/src/main/java/rx/subjects/BehaviorSubject.java b/src/main/java/rx/subjects/BehaviorSubject.java
index 5fb1f5e71b..c4d73751df 100644
--- a/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/src/main/java/rx/subjects/BehaviorSubject.java
@@ -20,7 +20,6 @@
 import java.util.*;
 
 import rx.Observer;
-import rx.annotations.Beta;
 import rx.exceptions.Exceptions;
 import rx.functions.Action1;
 import rx.internal.operators.NotificationLite;
@@ -178,8 +177,8 @@ public boolean hasObservers() {
      * <p>Note that unless {@link #hasCompleted()} or {@link #hasThrowable()} returns true, the value
      * retrieved by {@code getValue()} may get outdated.
      * @return true if and only if the subject has some value and hasn't terminated yet.
+     * @since 1.2
      */
-    @Beta
     public boolean hasValue() {
         Object o = state.getLatest();
         return nl.isNext(o);
@@ -187,8 +186,8 @@ public boolean hasValue() {
     /**
      * Check if the Subject has terminated with an exception.
      * @return true if the subject has received a throwable through {@code onError}.
+     * @since 1.2
      */
-    @Beta
     public boolean hasThrowable() {
         Object o = state.getLatest();
         return nl.isError(o);
@@ -196,8 +195,8 @@ public boolean hasThrowable() {
     /**
      * Check if the Subject has terminated normally.
      * @return true if the subject completed normally via {@code onCompleted()}
+     * @since 1.2
      */
-    @Beta
     public boolean hasCompleted() {
         Object o = state.getLatest();
         return nl.isCompleted(o);
@@ -210,8 +209,8 @@ public boolean hasCompleted() {
      * exception or the Subject terminated (with or without receiving any value).
      * @return the current value or {@code null} if the Subject doesn't have a value,
      * has terminated or has an actual {@code null} as a valid value.
+     * @since 1.2
      */
-    @Beta
     public T getValue() {
         Object o = state.getLatest();
         if (nl.isNext(o)) {
@@ -223,8 +222,8 @@ public T getValue() {
      * Returns the Throwable that terminated the Subject.
      * @return the Throwable that terminated the Subject or {@code null} if the
      * subject hasn't terminated yet or it terminated normally.
+     * @since 1.2
      */
-    @Beta
     public Throwable getThrowable() {
         Object o = state.getLatest();
         if (nl.isError(o)) {
@@ -237,8 +236,8 @@ public Throwable getThrowable() {
      * the provided {@code a} array or creates a new array if it has not enough capacity.
      * @param a the array to fill in
      * @return the array {@code a} if it had enough capacity or a new array containing the available values
+     * @since 1.2
      */
-    @Beta
     @SuppressWarnings("unchecked")
     public T[] getValues(T[] a) {
         Object o = state.getLatest();
@@ -259,13 +258,13 @@ public T[] getValues(T[] a) {
 
     /**
      * Returns a snapshot of the currently buffered non-terminal events.
-     * <p>The operation is threadsafe.
+     * <p>The operation is thread-safe.
      *
      * @return a snapshot of the currently buffered non-terminal events.
      * @since (If this graduates from being an Experimental class method, replace this parenthetical with the release number)
+     * @since 1.2
      */
     @SuppressWarnings("unchecked")
-    @Beta
     public Object[] getValues() {
         T[] r = getValues((T[])EMPTY_ARRAY);
         if (r == EMPTY_ARRAY) {
diff --git a/src/main/java/rx/subjects/PublishSubject.java b/src/main/java/rx/subjects/PublishSubject.java
index 05f89c48c9..eda6945a45 100644
--- a/src/main/java/rx/subjects/PublishSubject.java
+++ b/src/main/java/rx/subjects/PublishSubject.java
@@ -20,7 +20,6 @@
 
 import rx.*;
 import rx.Observer;
-import rx.annotations.Beta;
 import rx.exceptions.*;
 import rx.internal.operators.BackpressureUtils;
 
@@ -92,16 +91,16 @@ public boolean hasObservers() {
     /**
      * Check if the Subject has terminated with an exception.
      * @return true if the subject has received a throwable through {@code onError}.
+     * @since 1.2
      */
-    @Beta
     public boolean hasThrowable() {
         return state.get() == PublishSubjectState.TERMINATED && state.error != null;
     }
     /**
      * Check if the Subject has terminated normally.
      * @return true if the subject completed normally via {@code onCompleted}
+     * @since 1.2
      */
-    @Beta
     public boolean hasCompleted() {
         return state.get() == PublishSubjectState.TERMINATED && state.error == null;
     }
@@ -109,8 +108,8 @@ public boolean hasCompleted() {
      * Returns the Throwable that terminated the Subject.
      * @return the Throwable that terminated the Subject or {@code null} if the
      * subject hasn't terminated yet or it terminated normally.
+     * @since 1.2
      */
-    @Beta
     public Throwable getThrowable() {
         if (state.get() == PublishSubjectState.TERMINATED) {
             return state.error;
diff --git a/src/main/java/rx/subjects/ReplaySubject.java b/src/main/java/rx/subjects/ReplaySubject.java
index 6358872588..0bf2ed7f90 100644
--- a/src/main/java/rx/subjects/ReplaySubject.java
+++ b/src/main/java/rx/subjects/ReplaySubject.java
@@ -22,7 +22,6 @@
 
 import rx.*;
 import rx.Observer;
-import rx.annotations.Beta;
 import rx.exceptions.Exceptions;
 import rx.internal.operators.BackpressureUtils;
 import rx.plugins.RxJavaHooks;
@@ -267,16 +266,16 @@ public boolean hasObservers() {
     /**
      * Check if the Subject has terminated with an exception.
      * @return true if the subject has received a throwable through {@code onError}.
+     * @since 1.2
      */
-    @Beta
     public boolean hasThrowable() {
         return state.isTerminated() && state.buffer.error() != null;
     }
     /**
      * Check if the Subject has terminated normally.
      * @return true if the subject completed normally via {@code onCompleted}
+     * @since 1.2
      */
-    @Beta
     public boolean hasCompleted() {
         return state.isTerminated() && state.buffer.error() == null;
     }
@@ -284,8 +283,8 @@ public boolean hasCompleted() {
      * Returns the Throwable that terminated the Subject.
      * @return the Throwable that terminated the Subject or {@code null} if the
      * subject hasn't terminated yet or it terminated normally.
+     * @since 1.2
      */
-    @Beta
     public Throwable getThrowable() {
         if (state.isTerminated()) {
             return state.buffer.error();
@@ -295,19 +294,24 @@ public Throwable getThrowable() {
     /**
      * Returns the current number of items (non-terminal events) available for replay.
      * @return the number of items available
+     * @since 1.2
      */
-    @Beta
     public int size() {
         return state.buffer.size();
     }
+
     /**
      * @return true if the Subject holds at least one non-terminal event available for replay
+     * @since 1.2
      */
-    @Beta
     public boolean hasAnyValue() {
         return !state.buffer.isEmpty();
     }
-    @Beta
+
+    /**
+     * @return true if the Subject holds at least one non-terminal event available for replay
+     * @since 1.2
+     */
     public boolean hasValue() {
         return hasAnyValue();
     }
@@ -316,21 +320,20 @@ public boolean hasValue() {
      * the provided {@code a} array or creates a new array if it has not enough capacity.
      * @param a the array to fill in
      * @return the array {@code a} if it had enough capacity or a new array containing the available values
+     * @since 1.2
      */
-    @Beta
     public T[] getValues(T[] a) {
         return state.buffer.toArray(a);
     }
 
     /**
      * Returns a snapshot of the currently buffered non-terminal events.
-     * <p>The operation is threadsafe.
+     * <p>The operation is thread-safe.
      *
      * @return a snapshot of the currently buffered non-terminal events.
-     * @since (If this graduates from being an Experimental class method, replace this parenthetical with the release number)
+     * @since 1.2
      */
     @SuppressWarnings("unchecked")
-    @Beta
     public Object[] getValues() {
         T[] r = getValues((T[])EMPTY_ARRAY);
         if (r == EMPTY_ARRAY) {
@@ -339,7 +342,10 @@ public Object[] getValues() {
         return r;
     }
 
-    @Beta
+    /**
+     * @return the latest value available
+     * @since 1.2
+     */
     public T getValue() {
         return state.buffer.last();
     }
diff --git a/src/main/java/rx/subjects/UnicastSubject.java b/src/main/java/rx/subjects/UnicastSubject.java
index 92bd62a4f5..70f4a96a16 100644
--- a/src/main/java/rx/subjects/UnicastSubject.java
+++ b/src/main/java/rx/subjects/UnicastSubject.java
@@ -197,7 +197,7 @@ public void onError(Throwable e) {
                 error = e;
                 done = true;
                 if (!caughtUp) {
-                    boolean stillReplay = false;
+                    boolean stillReplay;
                     synchronized (this) {
                         stillReplay = !caughtUp;
                     }
@@ -217,7 +217,7 @@ public void onCompleted() {
 
                 done = true;
                 if (!caughtUp) {
-                    boolean stillReplay = false;
+                    boolean stillReplay;
                     synchronized (this) {
                         stillReplay = !caughtUp;
                     }
@@ -246,7 +246,7 @@ public void request(long n) {
         /**
          * Tries to set the given subscriber if not already set, sending an
          * IllegalStateException to the subscriber otherwise.
-         * @param subscriber
+         * @param subscriber the incoming Subscriber instance, not null
          */
         @Override
         public void call(Subscriber<? super T> subscriber) {
@@ -349,10 +349,10 @@ public boolean isUnsubscribed() {
         /**
          * Checks if one of the terminal conditions have been met: child unsubscribed,
          * an error happened or the source terminated and the queue is empty
-         * @param done
-         * @param empty
-         * @param s
-         * @return
+         * @param done indicates the source has called onCompleted
+         * @param empty indicates if there are no more source values in the queue
+         * @param s the target Subscriber to emit events to
+         * @return true if this Subject reached a terminal state and the drain loop should quit
          */
         boolean checkTerminated(boolean done, boolean empty, Subscriber<? super T> s) {
             if (s.isUnsubscribed()) {
diff --git a/src/main/java/rx/subscriptions/CompositeSubscription.java b/src/main/java/rx/subscriptions/CompositeSubscription.java
index 6b111af15e..c6d8aa35aa 100644
--- a/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -120,7 +120,7 @@ public void addAll(final Subscription... subscriptions) {
      */
     public void remove(final Subscription s) {
         if (!unsubscribed) {
-            boolean unsubscribe = false;
+            boolean unsubscribe;
             synchronized (this) {
                 if (unsubscribed || subscriptions == null) {
                     return;
@@ -141,7 +141,7 @@ public void remove(final Subscription s) {
      */
     public void clear() {
         if (!unsubscribed) {
-            Collection<Subscription> unsubscribe = null;
+            Collection<Subscription> unsubscribe;
             synchronized (this) {
                 if (unsubscribed || subscriptions == null) {
                     return;
@@ -162,7 +162,7 @@ public void clear() {
     @Override
     public void unsubscribe() {
         if (!unsubscribed) {
-            Collection<Subscription> unsubscribe = null;
+            Collection<Subscription> unsubscribe;
             synchronized (this) {
                 if (unsubscribed) {
                     return;
diff --git a/src/test/java/rx/ObservableConversionTest.java b/src/test/java/rx/ObservableConversionTest.java
deleted file mode 100644
index 0c5041bbb9..0000000000
--- a/src/test/java/rx/ObservableConversionTest.java
+++ /dev/null
@@ -1,251 +0,0 @@
-/**
- * Copyright 2016 Netflix, Inc.
- *
- * 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 rx;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
-
-import static org.junit.Assert.*;
-
-import org.junit.Test;
-
-import rx.Observable.OnSubscribe;
-import rx.Observable.Operator;
-import rx.exceptions.OnErrorNotImplementedException;
-import rx.functions.Func1;
-import rx.functions.Func2;
-import rx.internal.operators.OnSubscribeFilter;
-import rx.internal.operators.OnSubscribeMap;
-import rx.observers.TestSubscriber;
-import rx.schedulers.Schedulers;
-
-@SuppressWarnings("deprecation")
-public class ObservableConversionTest {
-
-    public static class Cylon {}
-
-    public static class Jail {
-        Object cylon;
-
-        Jail(Object cylon) {
-            this.cylon = cylon;
-        }
-    }
-
-    public static class CylonDetectorObservable<T> {
-        protected OnSubscribe<T> onSubscribe;
-
-        public static <T> CylonDetectorObservable<T> create(OnSubscribe<T> onSubscribe) {
-            return new CylonDetectorObservable<T>(onSubscribe);
-        }
-
-        protected CylonDetectorObservable(OnSubscribe<T> onSubscribe) {
-            this.onSubscribe = onSubscribe;
-        }
-
-        public void subscribe(Subscriber<T> subscriber) {
-            onSubscribe.call(subscriber);
-        }
-
-        public <R> CylonDetectorObservable<R> lift(Operator<? extends R, ? super T> operator) {
-            return x(new RobotConversionFunc<T, R>(operator));
-        }
-
-        public <R, O> O x(Func1<OnSubscribe<T>, O> operator) {
-            return operator.call(onSubscribe);
-        }
-
-        public <R> CylonDetectorObservable<? extends R> compose(Func1<CylonDetectorObservable<? super T>, CylonDetectorObservable<? extends R>> transformer) {
-            return transformer.call(this);
-        }
-
-        public final CylonDetectorObservable<T> beep(Func1<? super T, Boolean> predicate) {
-            return create(new OnSubscribeFilter<T>(Observable.create(onSubscribe), predicate));
-        }
-
-        public final <R> CylonDetectorObservable<R> boop(Func1<? super T, ? extends R> func) {
-            return create(new OnSubscribeMap<T, R>(Observable.create(onSubscribe), func));
-        }
-
-        public CylonDetectorObservable<String> DESTROY() {
-            return boop(new Func1<T, String>() {
-                @Override
-                public String call(T t) {
-                    Object cylon = ((Jail) t).cylon;
-                    throwOutTheAirlock(cylon);
-                    if (t instanceof Jail) {
-                        String name = cylon.toString();
-                        return "Cylon '" + name + "' has been destroyed";
-                    }
-                    else {
-                        return "Cylon 'anonymous' has been destroyed";
-                    }
-                }});
-        }
-
-        private static void throwOutTheAirlock(Object cylon) {
-            // ...
-        }
-    }
-
-    public static class RobotConversionFunc<T, R> implements Func1<OnSubscribe<T>, CylonDetectorObservable<R>> {
-        private Operator<? extends R, ? super T> operator;
-
-        public RobotConversionFunc(Operator<? extends R, ? super T> operator) {
-            this.operator = operator;
-        }
-
-        @Override
-        public CylonDetectorObservable<R> call(final OnSubscribe<T> onSubscribe) {
-            return CylonDetectorObservable.create(new OnSubscribe<R>() {
-                @Override
-                public void call(Subscriber<? super R> o) {
-                    try {
-                        Subscriber<? super T> st = operator.call(o);
-                        try {
-                            st.onStart();
-                            onSubscribe.call(st);
-                        } catch (OnErrorNotImplementedException e) {
-                            throw e;
-                        } catch (Throwable e) {
-                            st.onError(e);
-                        }
-                    } catch (OnErrorNotImplementedException e) {
-                        throw e;
-                    } catch (Throwable e) {
-                        o.onError(e);
-                    }
-
-                }});
-        }
-    }
-
-    public static class ConvertToCylonDetector<T> implements Func1<OnSubscribe<T>, CylonDetectorObservable<T>> {
-        @Override
-        public CylonDetectorObservable<T> call(final OnSubscribe<T> onSubscribe) {
-            return CylonDetectorObservable.create(onSubscribe);
-        }
-    }
-
-    public static class ConvertToObservable<T> implements Func1<OnSubscribe<T>, Observable<T>> {
-        @Override
-        public Observable<T> call(final OnSubscribe<T> onSubscribe) {
-            return Observable.create(onSubscribe);
-        }
-    }
-
-    @Test
-    public void testConversionBetweenObservableClasses() {
-        final TestSubscriber<String> subscriber = new TestSubscriber<String>(new Subscriber<String>(){
-
-            @Override
-            public void onCompleted() {
-                System.out.println("Complete");
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                System.out.println("error: " + e.getMessage());
-                e.printStackTrace();
-            }
-
-            @Override
-            public void onNext(String t) {
-                System.out.println(t);
-            }});
-        List<Object> crewOfBattlestarGalactica = Arrays.asList(new Object[] {"William Adama", "Laura Roslin", "Lee Adama", new Cylon()});
-        Observable.from(crewOfBattlestarGalactica)
-            .extend(new ConvertToCylonDetector<Object>())
-            .beep(new Func1<Object, Boolean>(){
-                @Override
-                public Boolean call(Object t) {
-                    return t instanceof Cylon;
-                }})
-             .boop(new Func1<Object, Object>() {
-                @Override
-                public Jail call(Object cylon) {
-                    return new Jail(cylon);
-                }})
-            .DESTROY()
-            .x(new ConvertToObservable<String>())
-            .reduce("Cylon Detector finished. Report:\n", new Func2<String, String, String>() {
-                @Override
-                public String call(String a, String n) {
-                    return a + n + "\n";
-                }})
-            .subscribe(subscriber);
-        subscriber.assertNoErrors();
-        subscriber.assertCompleted();
-    }
-
-    @Test
-    public void testConvertToConcurrentQueue() {
-        final AtomicReference<Throwable> thrown = new AtomicReference<Throwable>(null);
-        final AtomicBoolean isFinished = new AtomicBoolean(false);
-        ConcurrentLinkedQueue<? extends Integer> queue = Observable.range(0,5)
-                .flatMap(new Func1<Integer, Observable<Integer>>(){
-                    @Override
-                    public Observable<Integer> call(final Integer i) {
-                        return Observable.range(0, 5)
-                                .observeOn(Schedulers.io())
-                                .map(new Func1<Integer, Integer>(){
-                                    @Override
-                                    public Integer call(Integer k) {
-                                        try {
-                                            Thread.sleep(System.currentTimeMillis() % 100);
-                                        } catch (InterruptedException e) {
-                                            e.printStackTrace();
-                                        }
-                                        return i + k;
-                                    }});
-                    }})
-                    .extend(new Func1<OnSubscribe<Integer>, ConcurrentLinkedQueue<Integer>>() {
-                        @Override
-                        public ConcurrentLinkedQueue<Integer> call(OnSubscribe<Integer> onSubscribe) {
-                            final ConcurrentLinkedQueue<Integer> q = new ConcurrentLinkedQueue<Integer>();
-                            onSubscribe.call(new Subscriber<Integer>(){
-                                @Override
-                                public void onCompleted() {
-                                    isFinished.set(true);
-                                }
-
-                                @Override
-                                public void onError(Throwable e) {
-                                    thrown.set(e);
-                                }
-
-                                @Override
-                                public void onNext(Integer t) {
-                                    q.add(t);
-                                }});
-                            return q;
-                        }});
-
-        int x = 0;
-        while(!isFinished.get()) {
-            Integer i = queue.poll();
-            if (i != null) {
-                x++;
-                System.out.println(x + " item: " + i);
-            }
-        }
-        assertEquals(null, thrown.get());
-    }
-}
diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
index 3614af3af7..433d56331b 100644
--- a/src/test/java/rx/ObservableTests.java
+++ b/src/test/java/rx/ObservableTests.java
@@ -1107,22 +1107,6 @@ public void testForEachWithNull() {
         .forEach(null);
     }
 
-    @SuppressWarnings("deprecation")
-    @Test
-    public void testExtend() {
-        final TestSubscriber<Object> subscriber = new TestSubscriber<Object>();
-        final Object value = new Object();
-        Observable.just(value).extend(new Func1<OnSubscribe<Object>,Object>(){
-            @Override
-            public Object call(OnSubscribe<Object> onSubscribe) {
-                onSubscribe.call(subscriber);
-                subscriber.assertNoErrors();
-                subscriber.assertCompleted();
-                subscriber.assertValue(value);
-                return subscriber.getOnNextEvents().get(0);
-            }});
-    }
-
     @Test
     public void nullOnSubscribe() {
         Observable<Integer> source = Observable.create((OnSubscribe<Integer>)null);

From 010256b0e19bdb18f136f80a4dc48c0a53c3da41 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 15 Sep 2016 10:16:28 +0200
Subject: [PATCH 170/263] 1.x: safeguard against building with 2.* tags (#4556)

---
 gradle/buildViaTravis.sh | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/gradle/buildViaTravis.sh b/gradle/buildViaTravis.sh
index 3da975d72f..d3d2ce6b96 100755
--- a/gradle/buildViaTravis.sh
+++ b/gradle/buildViaTravis.sh
@@ -3,6 +3,13 @@
 
 git fsck --full
 
+buildTag="$TRAVIS_TAG"
+
+if [ "$buildTag" != "" ] && [ "${buildTag:0:3}" != "v1." ]; then
+   echo -e "Wrong tag on the 1.x brach: $buildTag : build stopped"
+   exit 1
+fi
+
 if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
   echo -e "Build Pull Request #$TRAVIS_PULL_REQUEST => Branch [$TRAVIS_BRANCH]"
   ./gradlew -Prelease.useLastTag=true build --stacktrace

From 01e68d3f9b92a6bc50956ac6995bccde37ddcff5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?D=C3=A1vid=20Karnok?= <akarnokd@gmail.com>
Date: Sat, 17 Sep 2016 15:16:21 +0200
Subject: [PATCH 171/263] 1.2.0 changes.md

---
 CHANGES.md | 127 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 127 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 2a9bd70a0c..a48700b7e9 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,132 @@
 # RxJava Releases #
 
+### Version 1.2.0 - September 17, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.0%7C))
+
+This is a minor release that is functionally equivalent to 1.1.10 minus the removal of some deprecated experimental APIs.
+
+#### Promote `@Beta` to standard (`@since 1.2`)
+
+  - in `rx.Observable`
+    - `create(SyncOnSubscribe<S, T>)`
+    - `doOnRequest(Action1<Long>)`
+    - `flatMap(Func1<? super T, ? extends Observable<? extends R>>, Func1<? super Throwable, ? extends Observable<? extends R>>, Func0<? extends Observable<? extends R>>, int)`
+    - `flatMap(Func1<? super T, ? extends Observable<? extends R>>, int)`
+    - `flatMap(Func1<? super T, ? extends Observable<? extends U>>, Func2<? super T, ? super U, ? extends R>, int)`
+    - `flatMapIterable(Func1<? super T, ? extends Iterable<? extends R>>, int)
+rx.Observable.flatMapIterable(Func1<? super T, ? extends Iterable<? extends U>>, Func2<? super T, ? super U, ? extends R>, int)`
+    - `fromCallable(Callable<? extends T>)`
+    - `toSingle()`
+  - `rx.Single` (the class itself)
+    - `fromCallable(Callable<? extends T>)`
+  - `rx.SingleSubscriber<T>`
+  - in `rx.observables.ConnectableObservable`
+    - `autoConnect()`
+    - `autoConnect(int, Action1<? super Subscription>)`
+    - `autoConnect(int)`
+  - `rx.observables.SyncOnSubscribe<S, T>`
+  - in `rx.subjects.AsyncSubject`
+    - `getThrowable()`
+    - `getValue()`
+    - `hasCompleted()`
+    - `hasThrowable()`
+    - `hasValue()`
+  - in `rx.subjects.BehaviorSubject`
+    - `getThrowable()`
+    - `getValue()`
+    - `getValues()`
+    - `getValues(T[])`
+    - `hasCompleted()`
+    - `hasThrowable()`
+    - `hasValue()`
+  - in `rx.subjects.PublishSubject`
+    - `getThrowable()`
+    - `hasCompleted()`
+    - `hasThrowable()`
+  - in `rx.subjects.ReplaySubject`
+    - `getThrowable()`
+    - `getValue()`
+    - `getValues()`
+    - `getValues(T[])`
+    - `hasAnyValue()`
+    - `hasCompleted()`
+    - `hasThrowable()`
+    - `hasValue()`
+    - `size()`
+
+#### Promote `@Experimental` to `@Beta`
+
+  - `rx.BackpressureOverflow`
+  - in `rx.Observable`
+    - `concatDelayError(Iterable<? extends Observable<? extends T>>)`
+    - `concatDelayError(Observable<? extends Observable<? extends T>>)`
+    - `concatEager(Iterable<? extends Observable<? extends T>>, int)`
+    - `concatEager(Iterable<? extends Observable<? extends T>>)`
+    - `concatEager(Observable<? extends Observable<? extends T>>, int)`
+    - `concatEager(Observable<? extends Observable<? extends T>>)`
+    - `concatEager(Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>)`
+    - `concatEager(Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>)`
+    - `concatEager(Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>)`
+    - `concatEager(Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>)`
+    - `concatEager(Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>)`
+    - `concatEager(Observable<? extends T>, Observable<? extends T>, Observable<? extends T>, Observable<? extends T>)`
+    - `concatEager(Observable<? extends T>, Observable<? extends T>, Observable<? extends T>)`
+    - `concatEager(Observable<? extends T>, Observable<? extends T>)`
+    - `concatMapDelayError(Func1<? super T, ? extends Observable<? extends R>>)`
+    - `concatMapEager(Func1<? super T, ? extends Observable<? extends R>>, int, int)`
+    - `concatMapEager(Func1<? super T, ? extends Observable<? extends R>>, int)`
+    - `concatMapEager(Func1<? super T, ? extends Observable<? extends R>>)`
+    - `delaySubscription(Observable<U>)`
+    - `distinctUntilChanged(Func2<? super T, ? super T, Boolean>)`
+    - `mergeDelayError(Observable<? extends Observable<? extends T>>, int)`
+    - `onBackpressureBuffer(long, Action0, Strategy)`
+    - `switchMapDelayError(Func1<? super T, ? extends Observable<? extends R>>)`
+    - `switchOnNextDelayError(Observable<? extends Observable<? extends T>>)`
+    - `toCompletable()`
+    - `toSortedList(Func2<? super T, ? super T, Integer>, int)`
+    - `toSortedList(int)`
+    - `using(Func0<Resource>, Func1<? super Resource, ? extends Observable<? extends T>>, Action1<? super Resource>, boolean)`
+  - in `rx.observables.BlockingObservable`
+    - `subscribe()`
+    - `subscribe(Action1<? super T>, Action1<? super Throwable>, Action0)`
+    - `subscribe(Action1<? super T>, Action1<? super Throwable>)`
+    - `subscribe(Action1<? super T>)`
+    - `subscribe(Observer<? super T>)`
+    - `subscribe(Subscriber<? super T>)`
+  - `rx.Completable`
+  - in `rx.Single`
+    - `defer(Callable<Single<T>>)`
+    - `delay(long, TimeUnit, Scheduler)`
+    - `delay(long, TimeUnit)`
+    - `delaySubscription(Observable<?>)`
+    - `doAfterTerminate(Action0)`
+    - `doOnError(Action1<Throwable>)`
+    - `doOnSubscribe(Action0)`
+    - `doOnSuccess(Action1<? super T>)`
+    - `doOnUnsubscribe(Action0)`
+    - `lift(Operator<? extends R, ? super T>)`
+    - `onErrorResumeNext(Func1<Throwable, ? extends Single<? extends T>>)`
+    - `onErrorResumeNext(Single<? extends T>)`
+    - `toBlocking()`
+    - `toCompletable()`
+    - `using(Func0<Resource>, Func1<? super Resource, ? extends Single<? extends T>>, Action1<? super Resource>, boolean)`
+    - `using(Func0<Resource>, Func1<? super Resource, ? extends Single<? extends T>>, Action1<? super Resource>)`
+  - `rx.exceptions.CompositeException.CompositeException(Throwable...)`
+  - in `rx.exceptions.Exceptions`
+    - `throwOrReport(Throwable, Observer<?>, Object)`
+    - `throwOrReport(Throwable, Observer<?>)`
+    - `throwOrReport(Throwable, SingleSubscriber<?>)`
+- `rx.singles.BlockingSingle<T>`
+
+#### Removed
+  - in `rx.Observable`
+    - `extend(Func1<OnSubscribe<T>, R>)` : use `to(Func1)` instead
+    - `fromAsync()` : renamed to `fromEmitter()`
+  - in `rx.Completable`
+    - `CompletableSubscriber` : now `rx.CompletableSubscriber`
+    - `CompletableOnSubscribe` : renamed to `Completable.OnSubscribe`
+    - `CompletableOperator` : renamed to `Completable.Operator`
+    - `CompletableTransformer` : renamed to `Completable.Transformer`
+
 ### Version 1.1.10 - September 5, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.1.10%7C))
 
 The release contains a few javadoc and internal cleanups, some enhancements and some deprecations.

From 646be2d18df9cd1537d81d22b24084049faa3581 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Thu, 22 Sep 2016 17:00:38 +1000
Subject: [PATCH 172/263] enhance generics doOnError doOnRequest (#4555)

---
 src/main/java/rx/Observable.java                 |  4 ++--
 .../internal/operators/OperatorDoOnRequest.java  |  4 ++--
 .../java/rx/internal/util/ActionObserver.java    |  4 ++--
 src/test/java/rx/ObservableDoOnTest.java         | 16 ++++++++++++++++
 .../operators/OperatorDoOnRequestTest.java       | 16 ++++++++++++++++
 5 files changed, 38 insertions(+), 6 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 2aba15801c..45245ddc99 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -5879,7 +5879,7 @@ public final Observable<T> doOnEach(Observer<? super T> observer) {
      * @return the source Observable with the side-effecting behavior applied
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
      */
-    public final Observable<T> doOnError(final Action1<Throwable> onError) {
+    public final Observable<T> doOnError(final Action1<? super Throwable> onError) {
         Action1<T> onNext = Actions.empty();
         Action0 onCompleted = Actions.empty();
         Observer<T> observer = new ActionObserver<T>(onNext, onError, onCompleted);
@@ -5934,7 +5934,7 @@ public final Observable<T> doOnNext(final Action1<? super T> onNext) {
      *      documentation: Do</a>
      * @since 1.2
      */
-    public final Observable<T> doOnRequest(final Action1<Long> onRequest) {
+    public final Observable<T> doOnRequest(final Action1<? super Long> onRequest) {
         return lift(new OperatorDoOnRequest<T>(onRequest));
     }
 
diff --git a/src/main/java/rx/internal/operators/OperatorDoOnRequest.java b/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
index c8da34ac5d..3c26a73846 100644
--- a/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
+++ b/src/main/java/rx/internal/operators/OperatorDoOnRequest.java
@@ -28,9 +28,9 @@
  */
 public class OperatorDoOnRequest<T> implements Operator<T, T> {
 
-    final Action1<Long> request;
+    final Action1<? super Long> request;
 
-    public OperatorDoOnRequest(Action1<Long> request) {
+    public OperatorDoOnRequest(Action1<? super Long> request) {
         this.request = request;
     }
 
diff --git a/src/main/java/rx/internal/util/ActionObserver.java b/src/main/java/rx/internal/util/ActionObserver.java
index cac8e7b47a..151a0c5f10 100644
--- a/src/main/java/rx/internal/util/ActionObserver.java
+++ b/src/main/java/rx/internal/util/ActionObserver.java
@@ -25,10 +25,10 @@
 public final class ActionObserver<T> implements Observer<T> {
 
     final Action1<? super T> onNext;
-    final Action1<Throwable> onError;
+    final Action1<? super Throwable> onError;
     final Action0 onCompleted;
 
-    public ActionObserver(Action1<? super T> onNext, Action1<Throwable> onError, Action0 onCompleted) {
+    public ActionObserver(Action1<? super T> onNext, Action1<? super Throwable> onError, Action0 onCompleted) {
         this.onNext = onNext;
         this.onError = onError;
         this.onCompleted = onCompleted;
diff --git a/src/test/java/rx/ObservableDoOnTest.java b/src/test/java/rx/ObservableDoOnTest.java
index ffd73ea450..44c7ea6ef1 100644
--- a/src/test/java/rx/ObservableDoOnTest.java
+++ b/src/test/java/rx/ObservableDoOnTest.java
@@ -27,6 +27,7 @@
 
 import rx.functions.Action0;
 import rx.functions.Action1;
+import rx.observers.TestSubscriber;
 
 public class ObservableDoOnTest {
 
@@ -65,6 +66,21 @@ public void call(Throwable v) {
         assertNotNull(t);
         assertEquals(t, r.get());
     }
+    
+    @Test
+    public void testDoOnErrorWithActionOfTypeObject() {
+        final AtomicReference<Boolean> r = new AtomicReference<Boolean>();
+        TestSubscriber<String> ts = TestSubscriber.create();
+        Observable.<String> error(new RuntimeException("an error"))
+            .doOnError(new Action1<Object>() {
+
+                @Override
+                public void call(Object v) {
+                    r.set(true);
+                }
+            }).subscribe(ts);
+        assertTrue(r.get());
+    }
 
     @Test
     public void testDoOnCompleted() {
diff --git a/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java b/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
index 3d1dcb4ca5..de99e1f726 100644
--- a/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
@@ -27,6 +27,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.functions.*;
+import rx.observers.TestSubscriber;
 
 public class OperatorDoOnRequestTest {
 
@@ -140,4 +141,19 @@ public void setProducer(Producer p) {
             Assert.assertEquals(Arrays.asList(0L, 1L), requested);
         }
     }
+    
+    @Test
+    public void canCallDoOnRequestWithActionOfTypeObject() {
+        final AtomicReference<Boolean> r = new AtomicReference<Boolean>();
+        TestSubscriber<String> ts = TestSubscriber.create();
+        Observable.just("a").doOnRequest(
+            new Action1<Object>() {
+
+                @Override
+                public void call(Object v) {
+                    r.set(true);
+                }
+            }).subscribe(ts);
+        assertTrue(r.get());
+    }
 }

From 4328619b760eebe2bdf6aea1e9b531ff1e20a500 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Sun, 25 Sep 2016 06:39:11 +1000
Subject: [PATCH 173/263] rename AsyncEmitter to Emitter (#4580)

---
 src/main/java/rx/AsyncEmitter.java            |   2 +
 src/main/java/rx/CompletableEmitter.java      |   2 +
 src/main/java/rx/Emitter.java                 |  85 ++
 src/main/java/rx/Observable.java              |  49 ++
 src/main/java/rx/functions/Cancellable.java   |  34 +
 .../operators/CompletableFromEmitter.java     |   2 +-
 .../OnSubscribeFromAsyncEmitter.java          | 571 +++++++++++++
 .../operators/OnSubscribeFromEmitter.java     |  63 +-
 .../OnSubscribeFromAsyncEmitterTest.java      | 807 ++++++++++++++++++
 .../operators/OnSubscribeFromEmitterTest.java | 115 +--
 10 files changed, 1641 insertions(+), 89 deletions(-)
 create mode 100644 src/main/java/rx/Emitter.java
 create mode 100644 src/main/java/rx/functions/Cancellable.java
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java
 create mode 100644 src/test/java/rx/internal/operators/OnSubscribeFromAsyncEmitterTest.java

diff --git a/src/main/java/rx/AsyncEmitter.java b/src/main/java/rx/AsyncEmitter.java
index 89b578d3f4..0dd132fcdb 100644
--- a/src/main/java/rx/AsyncEmitter.java
+++ b/src/main/java/rx/AsyncEmitter.java
@@ -29,8 +29,10 @@
  *
  * @param <T> the value type to emit
  * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ * @deprecated as of 1.2.1 because Async prefix of this class potentially misleading. Use {@link Emitter} instead.
  */
 @Experimental
+@Deprecated
 public interface AsyncEmitter<T> extends Observer<T> {
 
     /**
diff --git a/src/main/java/rx/CompletableEmitter.java b/src/main/java/rx/CompletableEmitter.java
index fcbd1d0fa9..985e567d1d 100644
--- a/src/main/java/rx/CompletableEmitter.java
+++ b/src/main/java/rx/CompletableEmitter.java
@@ -25,8 +25,10 @@
  * All methods are thread-safe; calling onCompleted or onError twice or one after the other has
  * no effect.
  * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ * @deprecated as of 1.2.1 because `setCancellation` method will change signature (not name) for 1.2.2.
  */
 @Experimental
+@Deprecated
 public interface CompletableEmitter {
 
     /**
diff --git a/src/main/java/rx/Emitter.java b/src/main/java/rx/Emitter.java
new file mode 100644
index 0000000000..5ed8697b71
--- /dev/null
+++ b/src/main/java/rx/Emitter.java
@@ -0,0 +1,85 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx;
+
+import rx.annotations.Experimental;
+import rx.functions.Cancellable;
+
+/**
+ * Abstraction over a RxJava Subscriber that allows associating
+ * a resource with it and exposes the current number of downstream
+ * requested amount.
+ * <p>
+ * The onNext, onError and onCompleted methods should be called
+ * in a sequential manner, just like the Observer's methods. The
+ * other methods are thread-safe.
+ *
+ * @param <T> the value type to emit
+ * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ */
+@Experimental
+public interface Emitter<T> extends Observer<T> {
+
+    /**
+     * Sets a Subscription on this emitter; any previous Subscription
+     * or Cancellation will be unsubscribed/cancelled.
+     * @param s the subscription, null is allowed
+     */
+    void setSubscription(Subscription s);
+
+    /**
+     * Sets a Cancellable on this emitter; any previous Subscription
+     * or Cancellation will be unsubscribed/cancelled.
+     * @param c the cancellable resource, null is allowed
+     */
+    void setCancellation(Cancellable c);
+    /**
+     * The current outstanding request amount.
+     * <p>This method it thread-safe.
+     * @return the current outstanding request amount
+     */
+    long requested();
+
+    /**
+     * Options to handle backpressure in the emitter.
+     */
+    enum BackpressureMode {
+        /**
+         * No backpressure is applied as the onNext calls pass through the Emitter;
+         * note that this may cause {@link rx.exceptions.MissingBackpressureException} or {@link IllegalStateException}
+         * somewhere downstream.
+         */
+        NONE,
+        /**
+         * Signals a {@link rx.exceptions.MissingBackpressureException} if the downstream can't keep up.
+         */
+        ERROR,
+        /**
+         * Buffers (unbounded) all onNext calls until the downstream can consume them.
+         */
+        BUFFER,
+        /**
+         * Drops the incoming onNext value if the downstream can't keep up.
+         */
+        DROP,
+        /**
+         * Keeps the latest onNext value and overwrites it with newer ones until the downstream
+         * can consume it.
+         */
+        LATEST
+    }
+}
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 45245ddc99..8936d489ba 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -2016,9 +2016,58 @@ public static <T> Observable<T> from(T[] array) {
      * @see AsyncEmitter.BackpressureMode
      * @see AsyncEmitter.Cancellable
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @deprecated since 1.2.1 because Async prefix of AsyncEmitter class is potentially misleading. Use 
+     *            {@link #fromEmitter(Action1, Emitter.BackpressureMode)} instead.
      */
     @Experimental
+    @Deprecated
     public static <T> Observable<T> fromEmitter(Action1<AsyncEmitter<T>> emitter, AsyncEmitter.BackpressureMode backpressure) {
+        return create(new OnSubscribeFromAsyncEmitter<T>(emitter, backpressure));
+    }
+    
+    /**
+     * Provides an API (via a cold Observable) that bridges the reactive world with the callback-style,
+     * generally non-backpressured world.
+     * <p>
+     * Example:
+     * <pre><code>
+     * Observable.&lt;Event&gt;fromEmitter(emitter -&gt; {
+     *     Callback listener = new Callback() {
+     *         &#64;Override
+     *         public void onEvent(Event e) {
+     *             emitter.onNext(e);
+     *             if (e.isLast()) {
+     *                 emitter.onCompleted();
+     *             }
+     *         }
+     *
+     *         &#64;Override
+     *         public void onFailure(Exception e) {
+     *             emitter.onError(e);
+     *         }
+     *     };
+     *
+     *     AutoCloseable c = api.someMethod(listener);
+     *
+     *     emitter.setCancellation(c::close);
+     *
+     * }, BackpressureMode.BUFFER);
+     * </code></pre>
+     * <p>
+     * You should call the Emitter's onNext, onError and onCompleted methods in a serialized fashion. The
+     * rest of its methods are thread-safe.
+     *
+     * @param <T> the element type
+     * @param emitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
+     * @param backpressure the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
+     * @return the new Observable instance
+     * @see Emitter
+     * @see Emitter.BackpressureMode
+     * @see Emitter.Cancellable
+     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public static <T> Observable<T> fromEmitter(Action1<Emitter<T>> emitter, Emitter.BackpressureMode backpressure) {
         return create(new OnSubscribeFromEmitter<T>(emitter, backpressure));
     }
 
diff --git a/src/main/java/rx/functions/Cancellable.java b/src/main/java/rx/functions/Cancellable.java
new file mode 100644
index 0000000000..1109522d86
--- /dev/null
+++ b/src/main/java/rx/functions/Cancellable.java
@@ -0,0 +1,34 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.functions;
+
+import rx.annotations.Experimental;
+
+/**
+ * A functional interface that has a single close method that can throw.
+ */
+@Experimental
+public interface Cancellable {
+
+    /**
+     * Cancel the action or free a resource.
+     * 
+     * @throws Exception
+     *             on error
+     */
+    void cancel() throws Exception;
+}
\ No newline at end of file
diff --git a/src/main/java/rx/internal/operators/CompletableFromEmitter.java b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
index 912c147a5c..eca4c3bc0c 100644
--- a/src/main/java/rx/internal/operators/CompletableFromEmitter.java
+++ b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
@@ -21,7 +21,7 @@
 import rx.AsyncEmitter.Cancellable;
 import rx.exceptions.Exceptions;
 import rx.functions.Action1;
-import rx.internal.operators.OnSubscribeFromEmitter.CancellableSubscription;
+import rx.internal.operators.OnSubscribeFromAsyncEmitter.CancellableSubscription;
 import rx.internal.subscriptions.SequentialSubscription;
 import rx.plugins.RxJavaHooks;
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java b/src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java
new file mode 100644
index 0000000000..d3f5867254
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java
@@ -0,0 +1,571 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.Queue;
+import java.util.concurrent.atomic.*;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.exceptions.*;
+import rx.functions.Action1;
+import rx.internal.util.RxRingBuffer;
+import rx.internal.util.atomic.SpscUnboundedAtomicArrayQueue;
+import rx.internal.util.unsafe.*;
+import rx.plugins.RxJavaHooks;
+import rx.subscriptions.SerialSubscription;
+
+@Deprecated
+public final class OnSubscribeFromAsyncEmitter<T> implements OnSubscribe<T> {
+
+    final Action1<AsyncEmitter<T>> asyncEmitter;
+
+    final AsyncEmitter.BackpressureMode backpressure;
+
+    public OnSubscribeFromAsyncEmitter(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) {
+        this.asyncEmitter = asyncEmitter;
+        this.backpressure = backpressure;
+    }
+
+    @Override
+    public void call(Subscriber<? super T> t) {
+        BaseAsyncEmitter<T> emitter;
+
+        switch (backpressure) {
+        case NONE: {
+            emitter = new NoneAsyncEmitter<T>(t);
+            break;
+        }
+        case ERROR: {
+            emitter = new ErrorAsyncEmitter<T>(t);
+            break;
+        }
+        case DROP: {
+            emitter = new DropAsyncEmitter<T>(t);
+            break;
+        }
+        case LATEST: {
+            emitter = new LatestAsyncEmitter<T>(t);
+            break;
+        }
+        default: {
+            emitter = new BufferAsyncEmitter<T>(t, RxRingBuffer.SIZE);
+            break;
+        }
+        }
+
+        t.add(emitter);
+        t.setProducer(emitter);
+        asyncEmitter.call(emitter);
+
+    }
+
+    /**
+     * A Subscription that wraps an AsyncEmitter.Cancellable instance.
+     */
+    static final class CancellableSubscription
+    extends AtomicReference<AsyncEmitter.Cancellable>
+    implements Subscription {
+
+        /** */
+        private static final long serialVersionUID = 5718521705281392066L;
+
+        public CancellableSubscription(AsyncEmitter.Cancellable cancellable) {
+            super(cancellable);
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return get() == null;
+        }
+
+        @Override
+        public void unsubscribe() {
+            if (get() != null) {
+                AsyncEmitter.Cancellable c = getAndSet(null);
+                if (c != null) {
+                    try {
+                        c.cancel();
+                    } catch (Exception ex) {
+                        Exceptions.throwIfFatal(ex);
+                        RxJavaHooks.onError(ex);
+                    }
+                }
+            }
+        }
+    }
+
+    static abstract class BaseAsyncEmitter<T>
+    extends AtomicLong
+    implements AsyncEmitter<T>, Producer, Subscription {
+        /** */
+        private static final long serialVersionUID = 7326289992464377023L;
+
+        final Subscriber<? super T> actual;
+
+        final SerialSubscription serial;
+
+        public BaseAsyncEmitter(Subscriber<? super T> actual) {
+            this.actual = actual;
+            this.serial = new SerialSubscription();
+        }
+
+        @Override
+        public void onCompleted() {
+            if (actual.isUnsubscribed()) {
+                return;
+            }
+            try {
+                actual.onCompleted();
+            } finally {
+                serial.unsubscribe();
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            if (actual.isUnsubscribed()) {
+                return;
+            }
+            try {
+                actual.onError(e);
+            } finally {
+                serial.unsubscribe();
+            }
+        }
+
+        @Override
+        public final void unsubscribe() {
+            serial.unsubscribe();
+            onUnsubscribed();
+        }
+
+        void onUnsubscribed() {
+            // default is no-op
+        }
+
+        @Override
+        public final boolean isUnsubscribed() {
+            return serial.isUnsubscribed();
+        }
+
+        @Override
+        public final void request(long n) {
+            if (BackpressureUtils.validate(n)) {
+                BackpressureUtils.getAndAddRequest(this, n);
+                onRequested();
+            }
+        }
+
+        void onRequested() {
+            // default is no-op
+        }
+
+        @Override
+        public final void setSubscription(Subscription s) {
+            serial.set(s);
+        }
+
+        @Override
+        public final void setCancellation(AsyncEmitter.Cancellable c) {
+            setSubscription(new CancellableSubscription(c));
+        }
+
+        @Override
+        public final long requested() {
+            return get();
+        }
+    }
+
+    static final class NoneAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 3776720187248809713L;
+
+        public NoneAsyncEmitter(Subscriber<? super T> actual) {
+            super(actual);
+        }
+
+        @Override
+        public void onNext(T t) {
+            if (actual.isUnsubscribed()) {
+                return;
+            }
+
+            actual.onNext(t);
+
+            for (;;) {
+                long r = get();
+                if (r == 0L || compareAndSet(r, r - 1)) {
+                    return;
+                }
+            }
+        }
+
+    }
+
+    static abstract class NoOverflowBaseAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 4127754106204442833L;
+
+        public NoOverflowBaseAsyncEmitter(Subscriber<? super T> actual) {
+            super(actual);
+        }
+
+        @Override
+        public void onNext(T t) {
+            if (actual.isUnsubscribed()) {
+                return;
+            }
+
+            if (get() != 0) {
+                actual.onNext(t);
+                BackpressureUtils.produced(this, 1);
+            } else {
+                onOverflow();
+            }
+        }
+
+        abstract void onOverflow();
+    }
+
+    static final class DropAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 8360058422307496563L;
+
+        public DropAsyncEmitter(Subscriber<? super T> actual) {
+            super(actual);
+        }
+
+        @Override
+        void onOverflow() {
+            // nothing to do
+        }
+
+    }
+
+    static final class ErrorAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 338953216916120960L;
+
+        private boolean done;
+
+        public ErrorAsyncEmitter(Subscriber<? super T> actual) {
+            super(actual);
+        }
+
+
+        @Override
+        public void onNext(T t) {
+            if (done) {
+                return;
+            }
+            super.onNext(t);
+        }
+
+
+        @Override
+        public void onCompleted() {
+            if (done) {
+                return;
+            }
+            done = true;
+            super.onCompleted();
+        }
+
+
+        @Override
+        public void onError(Throwable e) {
+            if (done) {
+                RxJavaHooks.onError(e);
+                return;
+            }
+            done = true;
+            super.onError(e);
+        }
+
+
+        @Override
+        void onOverflow() {
+            onError(new MissingBackpressureException("fromEmitter: could not emit value due to lack of requests"));
+        }
+
+    }
+
+    static final class BufferAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 2427151001689639875L;
+
+        final Queue<Object> queue;
+
+        Throwable error;
+        volatile boolean done;
+
+        final AtomicInteger wip;
+
+        final NotificationLite<T> nl;
+
+        public BufferAsyncEmitter(Subscriber<? super T> actual, int capacityHint) {
+            super(actual);
+            this.queue = UnsafeAccess.isUnsafeAvailable()
+                    ? new SpscUnboundedArrayQueue<Object>(capacityHint)
+                    : new SpscUnboundedAtomicArrayQueue<Object>(capacityHint);
+            this.wip = new AtomicInteger();
+            this.nl = NotificationLite.instance();
+        }
+
+        @Override
+        public void onNext(T t) {
+            queue.offer(nl.next(t));
+            drain();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            error = e;
+            done = true;
+            drain();
+        }
+
+        @Override
+        public void onCompleted() {
+            done = true;
+            drain();
+        }
+
+        @Override
+        void onRequested() {
+            drain();
+        }
+
+        @Override
+        void onUnsubscribed() {
+            if (wip.getAndIncrement() == 0) {
+                queue.clear();
+            }
+        }
+
+        void drain() {
+            if (wip.getAndIncrement() != 0) {
+                return;
+            }
+
+            int missed = 1;
+            final Subscriber<? super T> a = actual;
+            final Queue<Object> q = queue;
+
+            for (;;) {
+                long r = get();
+                long e = 0L;
+
+                while (e != r) {
+                    if (a.isUnsubscribed()) {
+                        q.clear();
+                        return;
+                    }
+
+                    boolean d = done;
+
+                    Object o = q.poll();
+
+                    boolean empty = o == null;
+
+                    if (d && empty) {
+                        Throwable ex = error;
+                        if (ex != null) {
+                            super.onError(ex);
+                        } else {
+                            super.onCompleted();
+                        }
+                        return;
+                    }
+
+                    if (empty) {
+                        break;
+                    }
+
+                    a.onNext(nl.getValue(o));
+
+                    e++;
+                }
+
+                if (e == r) {
+                    if (a.isUnsubscribed()) {
+                        q.clear();
+                        return;
+                    }
+
+                    boolean d = done;
+
+                    boolean empty = q.isEmpty();
+
+                    if (d && empty) {
+                        Throwable ex = error;
+                        if (ex != null) {
+                            super.onError(ex);
+                        } else {
+                            super.onCompleted();
+                        }
+                        return;
+                    }
+                }
+
+                if (e != 0) {
+                    BackpressureUtils.produced(this, e);
+                }
+
+                missed = wip.addAndGet(-missed);
+                if (missed == 0) {
+                    break;
+                }
+            }
+        }
+    }
+
+    static final class LatestAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+
+        /** */
+        private static final long serialVersionUID = 4023437720691792495L;
+
+        final AtomicReference<Object> queue;
+
+        Throwable error;
+        volatile boolean done;
+
+        final AtomicInteger wip;
+
+        final NotificationLite<T> nl;
+
+        public LatestAsyncEmitter(Subscriber<? super T> actual) {
+            super(actual);
+            this.queue = new AtomicReference<Object>();
+            this.wip = new AtomicInteger();
+            this.nl = NotificationLite.instance();
+        }
+
+        @Override
+        public void onNext(T t) {
+            queue.set(nl.next(t));
+            drain();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            error = e;
+            done = true;
+            drain();
+        }
+
+        @Override
+        public void onCompleted() {
+            done = true;
+            drain();
+        }
+
+        @Override
+        void onRequested() {
+            drain();
+        }
+
+        @Override
+        void onUnsubscribed() {
+            if (wip.getAndIncrement() == 0) {
+                queue.lazySet(null);
+            }
+        }
+
+        void drain() {
+            if (wip.getAndIncrement() != 0) {
+                return;
+            }
+
+            int missed = 1;
+            final Subscriber<? super T> a = actual;
+            final AtomicReference<Object> q = queue;
+
+            for (;;) {
+                long r = get();
+                long e = 0L;
+
+                while (e != r) {
+                    if (a.isUnsubscribed()) {
+                        q.lazySet(null);
+                        return;
+                    }
+
+                    boolean d = done;
+
+                    Object o = q.getAndSet(null);
+
+                    boolean empty = o == null;
+
+                    if (d && empty) {
+                        Throwable ex = error;
+                        if (ex != null) {
+                            super.onError(ex);
+                        } else {
+                            super.onCompleted();
+                        }
+                        return;
+                    }
+
+                    if (empty) {
+                        break;
+                    }
+
+                    a.onNext(nl.getValue(o));
+
+                    e++;
+                }
+
+                if (e == r) {
+                    if (a.isUnsubscribed()) {
+                        q.lazySet(null);
+                        return;
+                    }
+
+                    boolean d = done;
+
+                    boolean empty = q.get() == null;
+
+                    if (d && empty) {
+                        Throwable ex = error;
+                        if (ex != null) {
+                            super.onError(ex);
+                        } else {
+                            super.onCompleted();
+                        }
+                        return;
+                    }
+                }
+
+                if (e != 0) {
+                    BackpressureUtils.produced(this, e);
+                }
+
+                missed = wip.addAndGet(-missed);
+                if (missed == 0) {
+                    break;
+                }
+            }
+        }
+    }
+
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java b/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
index 68bfb4ccbf..cfed34fc25 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
@@ -22,6 +22,7 @@
 import rx.Observable.OnSubscribe;
 import rx.exceptions.*;
 import rx.functions.Action1;
+import rx.functions.Cancellable;
 import rx.internal.util.RxRingBuffer;
 import rx.internal.util.atomic.SpscUnboundedAtomicArrayQueue;
 import rx.internal.util.unsafe.*;
@@ -30,59 +31,59 @@
 
 public final class OnSubscribeFromEmitter<T> implements OnSubscribe<T> {
 
-    final Action1<AsyncEmitter<T>> asyncEmitter;
+    final Action1<Emitter<T>> Emitter;
 
-    final AsyncEmitter.BackpressureMode backpressure;
+    final Emitter.BackpressureMode backpressure;
 
-    public OnSubscribeFromEmitter(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) {
-        this.asyncEmitter = asyncEmitter;
+    public OnSubscribeFromEmitter(Action1<Emitter<T>> Emitter, Emitter.BackpressureMode backpressure) {
+        this.Emitter = Emitter;
         this.backpressure = backpressure;
     }
 
     @Override
     public void call(Subscriber<? super T> t) {
-        BaseAsyncEmitter<T> emitter;
+        BaseEmitter<T> emitter;
 
         switch (backpressure) {
         case NONE: {
-            emitter = new NoneAsyncEmitter<T>(t);
+            emitter = new NoneEmitter<T>(t);
             break;
         }
         case ERROR: {
-            emitter = new ErrorAsyncEmitter<T>(t);
+            emitter = new ErrorEmitter<T>(t);
             break;
         }
         case DROP: {
-            emitter = new DropAsyncEmitter<T>(t);
+            emitter = new DropEmitter<T>(t);
             break;
         }
         case LATEST: {
-            emitter = new LatestAsyncEmitter<T>(t);
+            emitter = new LatestEmitter<T>(t);
             break;
         }
         default: {
-            emitter = new BufferAsyncEmitter<T>(t, RxRingBuffer.SIZE);
+            emitter = new BufferEmitter<T>(t, RxRingBuffer.SIZE);
             break;
         }
         }
 
         t.add(emitter);
         t.setProducer(emitter);
-        asyncEmitter.call(emitter);
+        Emitter.call(emitter);
 
     }
 
     /**
-     * A Subscription that wraps an AsyncEmitter.Cancellable instance.
+     * A Subscription that wraps an Cancellable instance.
      */
     static final class CancellableSubscription
-    extends AtomicReference<AsyncEmitter.Cancellable>
+    extends AtomicReference<Cancellable>
     implements Subscription {
 
         /** */
         private static final long serialVersionUID = 5718521705281392066L;
 
-        public CancellableSubscription(AsyncEmitter.Cancellable cancellable) {
+        public CancellableSubscription(Cancellable cancellable) {
             super(cancellable);
         }
 
@@ -94,7 +95,7 @@ public boolean isUnsubscribed() {
         @Override
         public void unsubscribe() {
             if (get() != null) {
-                AsyncEmitter.Cancellable c = getAndSet(null);
+                Cancellable c = getAndSet(null);
                 if (c != null) {
                     try {
                         c.cancel();
@@ -107,9 +108,9 @@ public void unsubscribe() {
         }
     }
 
-    static abstract class BaseAsyncEmitter<T>
+    static abstract class BaseEmitter<T>
     extends AtomicLong
-    implements AsyncEmitter<T>, Producer, Subscription {
+    implements Emitter<T>, Producer, Subscription {
         /** */
         private static final long serialVersionUID = 7326289992464377023L;
 
@@ -117,7 +118,7 @@ static abstract class BaseAsyncEmitter<T>
 
         final SerialSubscription serial;
 
-        public BaseAsyncEmitter(Subscriber<? super T> actual) {
+        public BaseEmitter(Subscriber<? super T> actual) {
             this.actual = actual;
             this.serial = new SerialSubscription();
         }
@@ -179,7 +180,7 @@ public final void setSubscription(Subscription s) {
         }
 
         @Override
-        public final void setCancellation(AsyncEmitter.Cancellable c) {
+        public final void setCancellation(Cancellable c) {
             setSubscription(new CancellableSubscription(c));
         }
 
@@ -189,12 +190,12 @@ public final long requested() {
         }
     }
 
-    static final class NoneAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+    static final class NoneEmitter<T> extends BaseEmitter<T> {
 
         /** */
         private static final long serialVersionUID = 3776720187248809713L;
 
-        public NoneAsyncEmitter(Subscriber<? super T> actual) {
+        public NoneEmitter(Subscriber<? super T> actual) {
             super(actual);
         }
 
@@ -216,12 +217,12 @@ public void onNext(T t) {
 
     }
 
-    static abstract class NoOverflowBaseAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+    static abstract class NoOverflowBaseEmitter<T> extends BaseEmitter<T> {
 
         /** */
         private static final long serialVersionUID = 4127754106204442833L;
 
-        public NoOverflowBaseAsyncEmitter(Subscriber<? super T> actual) {
+        public NoOverflowBaseEmitter(Subscriber<? super T> actual) {
             super(actual);
         }
 
@@ -242,12 +243,12 @@ public void onNext(T t) {
         abstract void onOverflow();
     }
 
-    static final class DropAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
+    static final class DropEmitter<T> extends NoOverflowBaseEmitter<T> {
 
         /** */
         private static final long serialVersionUID = 8360058422307496563L;
 
-        public DropAsyncEmitter(Subscriber<? super T> actual) {
+        public DropEmitter(Subscriber<? super T> actual) {
             super(actual);
         }
 
@@ -258,14 +259,14 @@ void onOverflow() {
 
     }
 
-    static final class ErrorAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
+    static final class ErrorEmitter<T> extends NoOverflowBaseEmitter<T> {
 
         /** */
         private static final long serialVersionUID = 338953216916120960L;
 
         private boolean done;
 
-        public ErrorAsyncEmitter(Subscriber<? super T> actual) {
+        public ErrorEmitter(Subscriber<? super T> actual) {
             super(actual);
         }
 
@@ -307,7 +308,7 @@ void onOverflow() {
 
     }
 
-    static final class BufferAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+    static final class BufferEmitter<T> extends BaseEmitter<T> {
 
         /** */
         private static final long serialVersionUID = 2427151001689639875L;
@@ -321,7 +322,7 @@ static final class BufferAsyncEmitter<T> extends BaseAsyncEmitter<T> {
 
         final NotificationLite<T> nl;
 
-        public BufferAsyncEmitter(Subscriber<? super T> actual, int capacityHint) {
+        public BufferEmitter(Subscriber<? super T> actual, int capacityHint) {
             super(actual);
             this.queue = UnsafeAccess.isUnsafeAvailable()
                     ? new SpscUnboundedArrayQueue<Object>(capacityHint)
@@ -438,7 +439,7 @@ void drain() {
         }
     }
 
-    static final class LatestAsyncEmitter<T> extends BaseAsyncEmitter<T> {
+    static final class LatestEmitter<T> extends BaseEmitter<T> {
 
         /** */
         private static final long serialVersionUID = 4023437720691792495L;
@@ -452,7 +453,7 @@ static final class LatestAsyncEmitter<T> extends BaseAsyncEmitter<T> {
 
         final NotificationLite<T> nl;
 
-        public LatestAsyncEmitter(Subscriber<? super T> actual) {
+        public LatestEmitter(Subscriber<? super T> actual) {
             super(actual);
             this.queue = new AtomicReference<Object>();
             this.wip = new AtomicInteger();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromAsyncEmitterTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromAsyncEmitterTest.java
new file mode 100644
index 0000000000..565e3561fe
--- /dev/null
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromAsyncEmitterTest.java
@@ -0,0 +1,807 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.junit.*;
+
+import rx.*;
+import rx.exceptions.*;
+import rx.functions.Action1;
+import rx.observers.TestSubscriber;
+import rx.plugins.RxJavaHooks;
+import rx.subjects.PublishSubject;
+
+/**
+ * @deprecated because AsyncEmitter is deprecated (replaced by Emitter).
+ */
+@Deprecated
+public class OnSubscribeFromAsyncEmitterTest {
+
+    PublishAsyncEmitter source;
+
+    PublishAsyncEmitterNoCancel sourceNoCancel;
+
+    TestSubscriber<Integer> ts;
+
+    @Before
+    public void before() {
+        source = new PublishAsyncEmitter();
+        sourceNoCancel = new PublishAsyncEmitterNoCancel();
+        ts = TestSubscriber.create(0L);
+    }
+
+    @Test
+    public void normalBuffered() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.requestMore(1);
+
+        ts.assertValue(1);
+
+        Assert.assertEquals(0, source.requested());
+
+        ts.requestMore(1);
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void normalDrop() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+
+        source.onNext(1);
+
+        ts.requestMore(1);
+
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.assertValues(2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void normalLatest() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+
+        source.onNext(1);
+
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.requestMore(1);
+
+        ts.assertValues(2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void normalNone() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void normalNoneRequested() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        ts.requestMore(2);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+
+    @Test
+    public void normalError() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.assertNoValues();
+        ts.assertError(MissingBackpressureException.class);
+        ts.assertNotCompleted();
+
+        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+    }
+
+    @Test
+    public void overflowErrorIsNotFollowedByAnotherErrorDueToOnNextFromUpstream() {
+        Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
+
+            @Override
+            public void call(AsyncEmitter<Integer> emitter) {
+                emitter.onNext(1);
+                //don't check for unsubscription
+                emitter.onNext(2);
+            }};
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+
+        ts.assertNoValues();
+        ts.assertError(MissingBackpressureException.class);
+        ts.assertNotCompleted();
+
+        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+    }
+
+    @Test
+    public void overflowErrorIsNotFollowedByAnotherCompletedDueToCompletedFromUpstream() {
+        Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
+
+            @Override
+            public void call(AsyncEmitter<Integer> emitter) {
+                emitter.onNext(1);
+                //don't check for unsubscription
+                emitter.onCompleted();
+            }};
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+
+        ts.assertNoValues();
+        ts.assertError(MissingBackpressureException.class);
+        ts.assertNotCompleted();
+
+        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+    }
+
+    @Test
+    public void overflowErrorIsNotFollowedByAnotherErrorDueToOnErrorFromUpstreamAndSecondErrorIsReportedToHook() {
+        try {
+            final List<Throwable> list = new CopyOnWriteArrayList<Throwable>();
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+                @Override
+                public void call(Throwable t) {
+                    list.add(t);
+                }});
+            final RuntimeException e = new RuntimeException();
+            Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
+
+                @Override
+                public void call(AsyncEmitter<Integer> emitter) {
+                    emitter.onNext(1);
+                    //don't check for unsubscription
+                    emitter.onError(e);
+                }};
+            Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+
+            ts.assertNoValues();
+            ts.assertError(MissingBackpressureException.class);
+            ts.assertNotCompleted();
+
+            Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+            assertEquals(Arrays.asList(e), list);
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+
+    @Test
+    public void errorBuffered() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertValue(1);
+
+        ts.requestMore(1);
+
+        ts.assertValues(1, 2);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void errorLatest() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertValues(2);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void errorNone() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertValues(1, 2);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedBuffer() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        ts.unsubscribe();
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedLatest() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        ts.unsubscribe();
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedError() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+        ts.unsubscribe();
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedDrop() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+        ts.unsubscribe();
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNone() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        ts.unsubscribe();
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNoCancelBuffer() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        ts.unsubscribe();
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNoCancelLatest() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        ts.unsubscribe();
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNoCancelError() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+        ts.unsubscribe();
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNoCancelDrop() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+        ts.unsubscribe();
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribedNoCancelNone() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        ts.unsubscribe();
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onError(new TestException());
+
+        ts.requestMore(1);
+
+        ts.assertNoValues();
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void deferredRequest() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.requestMore(2);
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void take() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.requestMore(2);
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void takeOne() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
+        ts.requestMore(2);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void requestExact() {
+        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        ts.requestMore(2);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void takeNoCancel() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onCompleted();
+
+        ts.requestMore(2);
+
+        ts.assertValues(1, 2);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void takeOneNoCancel() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
+        ts.requestMore(2);
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+        sourceNoCancel.onCompleted();
+
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void unsubscribeNoCancel() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        ts.requestMore(2);
+
+        sourceNoCancel.onNext(1);
+
+        ts.unsubscribe();
+
+        sourceNoCancel.onNext(2);
+
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertNotCompleted();
+    }
+
+
+    @Test
+    public void unsubscribeInline() {
+        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                unsubscribe();
+            }
+        };
+
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
+
+        sourceNoCancel.onNext(1);
+
+        ts1.assertValues(1);
+        ts1.assertNoErrors();
+        ts1.assertNotCompleted();
+    }
+
+    @Test
+    public void completeInline() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onCompleted();
+
+        ts.requestMore(2);
+
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void errorInline() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onError(new TestException());
+
+        ts.requestMore(2);
+
+        ts.assertValues(1);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void requestInline() {
+        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1) {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                requestMore(1);
+            }
+        };
+
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+
+        ts1.assertValues(1, 2);
+        ts1.assertNoErrors();
+        ts1.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribeInlineLatest() {
+        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                unsubscribe();
+            }
+        };
+
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+
+        sourceNoCancel.onNext(1);
+
+        ts1.assertValues(1);
+        ts1.assertNoErrors();
+        ts1.assertNotCompleted();
+    }
+
+    @Test
+    public void unsubscribeInlineExactLatest() {
+        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1L) {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                unsubscribe();
+            }
+        };
+
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+
+        sourceNoCancel.onNext(1);
+
+        ts1.assertValues(1);
+        ts1.assertNoErrors();
+        ts1.assertNotCompleted();
+    }
+
+    @Test
+    public void completeInlineLatest() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onCompleted();
+
+        ts.requestMore(2);
+
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void completeInlineExactLatest() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onCompleted();
+
+        ts.requestMore(1);
+
+        ts.assertValues(1);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+    }
+
+    @Test
+    public void errorInlineLatest() {
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onError(new TestException());
+
+        ts.requestMore(2);
+
+        ts.assertValues(1);
+        ts.assertError(TestException.class);
+        ts.assertNotCompleted();
+    }
+
+    @Test
+    public void requestInlineLatest() {
+        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1) {
+            @Override
+            public void onNext(Integer t) {
+                super.onNext(t);
+                requestMore(1);
+            }
+        };
+
+        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+
+        sourceNoCancel.onNext(1);
+        sourceNoCancel.onNext(2);
+
+        ts1.assertValues(1, 2);
+        ts1.assertNoErrors();
+        ts1.assertNotCompleted();
+    }
+
+    static final class PublishAsyncEmitter implements Action1<AsyncEmitter<Integer>>, Observer<Integer> {
+
+        final PublishSubject<Integer> subject;
+
+        AsyncEmitter<Integer> current;
+
+        public PublishAsyncEmitter() {
+            this.subject = PublishSubject.create();
+        }
+
+        long requested() {
+            return current.requested();
+        }
+
+        @Override
+        public void call(final AsyncEmitter<Integer> t) {
+
+            this.current = t;
+
+            final Subscription s = subject.subscribe(new Observer<Integer>() {
+
+                @Override
+                public void onCompleted() {
+                    t.onCompleted();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    t.onError(e);
+                }
+
+                @Override
+                public void onNext(Integer v) {
+                    t.onNext(v);
+                }
+
+            });
+
+            t.setCancellation(new AsyncEmitter.Cancellable() {
+                @Override
+                public void cancel() throws Exception {
+                    s.unsubscribe();
+                }
+            });;
+        }
+
+        @Override
+        public void onNext(Integer t) {
+            subject.onNext(t);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            subject.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            subject.onCompleted();
+        }
+    }
+
+    static final class PublishAsyncEmitterNoCancel implements Action1<AsyncEmitter<Integer>>, Observer<Integer> {
+
+        final PublishSubject<Integer> subject;
+
+        public PublishAsyncEmitterNoCancel() {
+            this.subject = PublishSubject.create();
+        }
+
+        @Override
+        public void call(final AsyncEmitter<Integer> t) {
+
+            subject.subscribe(new Observer<Integer>() {
+
+                @Override
+                public void onCompleted() {
+                    t.onCompleted();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    t.onError(e);
+                }
+
+                @Override
+                public void onNext(Integer v) {
+                    t.onNext(v);
+                }
+
+            });
+        }
+
+        @Override
+        public void onNext(Integer t) {
+            subject.onNext(t);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            subject.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            subject.onCompleted();
+        }
+    }
+
+}
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
index 61cb9d75ab..b7579b5b6f 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
@@ -27,28 +27,29 @@
 import rx.*;
 import rx.exceptions.*;
 import rx.functions.Action1;
+import rx.functions.Cancellable;
 import rx.observers.TestSubscriber;
 import rx.plugins.RxJavaHooks;
 import rx.subjects.PublishSubject;
 
 public class OnSubscribeFromEmitterTest {
 
-    PublishAsyncEmitter source;
+    PublishEmitter source;
 
-    PublishAsyncEmitterNoCancel sourceNoCancel;
+    PublishEmitterNoCancel sourceNoCancel;
 
     TestSubscriber<Integer> ts;
 
     @Before
     public void before() {
-        source = new PublishAsyncEmitter();
-        sourceNoCancel = new PublishAsyncEmitterNoCancel();
+        source = new PublishEmitter();
+        sourceNoCancel = new PublishEmitterNoCancel();
         ts = TestSubscriber.create(0L);
     }
 
     @Test
     public void normalBuffered() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -69,7 +70,7 @@ public void normalBuffered() {
 
     @Test
     public void normalDrop() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.DROP).subscribe(ts);
 
         source.onNext(1);
 
@@ -85,7 +86,7 @@ public void normalDrop() {
 
     @Test
     public void normalLatest() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.LATEST).subscribe(ts);
 
         source.onNext(1);
 
@@ -101,7 +102,7 @@ public void normalLatest() {
 
     @Test
     public void normalNone() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.NONE).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -114,7 +115,7 @@ public void normalNone() {
 
     @Test
     public void normalNoneRequested() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.NONE).subscribe(ts);
         ts.requestMore(2);
 
         source.onNext(1);
@@ -129,7 +130,7 @@ public void normalNoneRequested() {
 
     @Test
     public void normalError() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.ERROR).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -144,15 +145,15 @@ public void normalError() {
 
     @Test
     public void overflowErrorIsNotFollowedByAnotherErrorDueToOnNextFromUpstream() {
-        Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
+        Action1<Emitter<Integer>> source = new Action1<Emitter<Integer>>(){
 
             @Override
-            public void call(AsyncEmitter<Integer> emitter) {
+            public void call(Emitter<Integer> emitter) {
                 emitter.onNext(1);
                 //don't check for unsubscription
                 emitter.onNext(2);
             }};
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
 
         ts.assertNoValues();
         ts.assertError(MissingBackpressureException.class);
@@ -163,15 +164,15 @@ public void call(AsyncEmitter<Integer> emitter) {
 
     @Test
     public void overflowErrorIsNotFollowedByAnotherCompletedDueToCompletedFromUpstream() {
-        Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
+        Action1<Emitter<Integer>> source = new Action1<Emitter<Integer>>(){
 
             @Override
-            public void call(AsyncEmitter<Integer> emitter) {
+            public void call(Emitter<Integer> emitter) {
                 emitter.onNext(1);
                 //don't check for unsubscription
                 emitter.onCompleted();
             }};
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
 
         ts.assertNoValues();
         ts.assertError(MissingBackpressureException.class);
@@ -190,15 +191,15 @@ public void call(Throwable t) {
                     list.add(t);
                 }});
             final RuntimeException e = new RuntimeException();
-            Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
+            Action1<Emitter<Integer>> source = new Action1<Emitter<Integer>>(){
 
                 @Override
-                public void call(AsyncEmitter<Integer> emitter) {
+                public void call(Emitter<Integer> emitter) {
                     emitter.onNext(1);
                     //don't check for unsubscription
                     emitter.onError(e);
                 }};
-            Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+            Observable.fromEmitter(source, Emitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
 
             ts.assertNoValues();
             ts.assertError(MissingBackpressureException.class);
@@ -213,7 +214,7 @@ public void call(AsyncEmitter<Integer> emitter) {
 
     @Test
     public void errorBuffered() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -232,7 +233,7 @@ public void errorBuffered() {
 
     @Test
     public void errorLatest() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.LATEST).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -247,7 +248,7 @@ public void errorLatest() {
 
     @Test
     public void errorNone() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.NONE).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -262,7 +263,7 @@ public void errorNone() {
 
     @Test
     public void unsubscribedBuffer() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.unsubscribe();
 
         source.onNext(1);
@@ -278,7 +279,7 @@ public void unsubscribedBuffer() {
 
     @Test
     public void unsubscribedLatest() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.LATEST).subscribe(ts);
         ts.unsubscribe();
 
         source.onNext(1);
@@ -294,7 +295,7 @@ public void unsubscribedLatest() {
 
     @Test
     public void unsubscribedError() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.ERROR).subscribe(ts);
         ts.unsubscribe();
 
         source.onNext(1);
@@ -310,7 +311,7 @@ public void unsubscribedError() {
 
     @Test
     public void unsubscribedDrop() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.DROP).subscribe(ts);
         ts.unsubscribe();
 
         source.onNext(1);
@@ -326,7 +327,7 @@ public void unsubscribedDrop() {
 
     @Test
     public void unsubscribedNone() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.NONE).subscribe(ts);
         ts.unsubscribe();
 
         source.onNext(1);
@@ -342,7 +343,7 @@ public void unsubscribedNone() {
 
     @Test
     public void unsubscribedNoCancelBuffer() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.unsubscribe();
 
         sourceNoCancel.onNext(1);
@@ -358,7 +359,7 @@ public void unsubscribedNoCancelBuffer() {
 
     @Test
     public void unsubscribedNoCancelLatest() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
         ts.unsubscribe();
 
         sourceNoCancel.onNext(1);
@@ -374,7 +375,7 @@ public void unsubscribedNoCancelLatest() {
 
     @Test
     public void unsubscribedNoCancelError() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.ERROR).subscribe(ts);
         ts.unsubscribe();
 
         sourceNoCancel.onNext(1);
@@ -390,7 +391,7 @@ public void unsubscribedNoCancelError() {
 
     @Test
     public void unsubscribedNoCancelDrop() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.DROP).subscribe(ts);
         ts.unsubscribe();
 
         sourceNoCancel.onNext(1);
@@ -406,7 +407,7 @@ public void unsubscribedNoCancelDrop() {
 
     @Test
     public void unsubscribedNoCancelNone() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.NONE).subscribe(ts);
         ts.unsubscribe();
 
         sourceNoCancel.onNext(1);
@@ -422,7 +423,7 @@ public void unsubscribedNoCancelNone() {
 
     @Test
     public void deferredRequest() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -437,7 +438,7 @@ public void deferredRequest() {
 
     @Test
     public void take() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -452,7 +453,7 @@ public void take() {
 
     @Test
     public void takeOne() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
         ts.requestMore(2);
 
         source.onNext(1);
@@ -466,7 +467,7 @@ public void takeOne() {
 
     @Test
     public void requestExact() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.requestMore(2);
 
         source.onNext(1);
@@ -480,7 +481,7 @@ public void requestExact() {
 
     @Test
     public void takeNoCancel() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
@@ -495,7 +496,7 @@ public void takeNoCancel() {
 
     @Test
     public void takeOneNoCancel() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
         ts.requestMore(2);
 
         sourceNoCancel.onNext(1);
@@ -509,7 +510,7 @@ public void takeOneNoCancel() {
 
     @Test
     public void unsubscribeNoCancel() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.requestMore(2);
 
         sourceNoCancel.onNext(1);
@@ -534,7 +535,7 @@ public void onNext(Integer t) {
             }
         };
 
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts1);
 
         sourceNoCancel.onNext(1);
 
@@ -545,7 +546,7 @@ public void onNext(Integer t) {
 
     @Test
     public void completeInline() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
@@ -559,7 +560,7 @@ public void completeInline() {
 
     @Test
     public void errorInline() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onError(new TestException());
@@ -581,7 +582,7 @@ public void onNext(Integer t) {
             }
         };
 
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts1);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
@@ -601,7 +602,7 @@ public void onNext(Integer t) {
             }
         };
 
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts1);
 
         sourceNoCancel.onNext(1);
 
@@ -620,7 +621,7 @@ public void onNext(Integer t) {
             }
         };
 
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts1);
 
         sourceNoCancel.onNext(1);
 
@@ -631,7 +632,7 @@ public void onNext(Integer t) {
 
     @Test
     public void completeInlineLatest() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
@@ -645,7 +646,7 @@ public void completeInlineLatest() {
 
     @Test
     public void completeInlineExactLatest() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
@@ -659,7 +660,7 @@ public void completeInlineExactLatest() {
 
     @Test
     public void errorInlineLatest() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onError(new TestException());
@@ -681,7 +682,7 @@ public void onNext(Integer t) {
             }
         };
 
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
+        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts1);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
@@ -691,13 +692,13 @@ public void onNext(Integer t) {
         ts1.assertNotCompleted();
     }
 
-    static final class PublishAsyncEmitter implements Action1<AsyncEmitter<Integer>>, Observer<Integer> {
+    static final class PublishEmitter implements Action1<Emitter<Integer>>, Observer<Integer> {
 
         final PublishSubject<Integer> subject;
 
-        AsyncEmitter<Integer> current;
+        Emitter<Integer> current;
 
-        public PublishAsyncEmitter() {
+        public PublishEmitter() {
             this.subject = PublishSubject.create();
         }
 
@@ -706,7 +707,7 @@ long requested() {
         }
 
         @Override
-        public void call(final AsyncEmitter<Integer> t) {
+        public void call(final Emitter<Integer> t) {
 
             this.current = t;
 
@@ -729,7 +730,7 @@ public void onNext(Integer v) {
 
             });
 
-            t.setCancellation(new AsyncEmitter.Cancellable() {
+            t.setCancellation(new Cancellable() {
                 @Override
                 public void cancel() throws Exception {
                     s.unsubscribe();
@@ -753,16 +754,16 @@ public void onCompleted() {
         }
     }
 
-    static final class PublishAsyncEmitterNoCancel implements Action1<AsyncEmitter<Integer>>, Observer<Integer> {
+    static final class PublishEmitterNoCancel implements Action1<Emitter<Integer>>, Observer<Integer> {
 
         final PublishSubject<Integer> subject;
 
-        public PublishAsyncEmitterNoCancel() {
+        public PublishEmitterNoCancel() {
             this.subject = PublishSubject.create();
         }
 
         @Override
-        public void call(final AsyncEmitter<Integer> t) {
+        public void call(final Emitter<Integer> t) {
 
             subject.subscribe(new Observer<Integer>() {
 

From 2e06d4e7ba48381cc636068bad71a3373e575ee1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20Albertos?= <me@victoralbertos.com>
Date: Mon, 26 Sep 2016 23:22:57 +0200
Subject: [PATCH 174/263] @Beta and @Experimental annotations are not longer
 annotated with itself (#4610)

---
 src/main/java/rx/annotations/Beta.java         | 1 -
 src/main/java/rx/annotations/Experimental.java | 1 -
 2 files changed, 2 deletions(-)

diff --git a/src/main/java/rx/annotations/Beta.java b/src/main/java/rx/annotations/Beta.java
index 0bcb9d34c4..8625beaaa5 100644
--- a/src/main/java/rx/annotations/Beta.java
+++ b/src/main/java/rx/annotations/Beta.java
@@ -46,6 +46,5 @@
         ElementType.METHOD,
         ElementType.TYPE })
 @Documented
-@Beta
 public @interface Beta {
 }
\ No newline at end of file
diff --git a/src/main/java/rx/annotations/Experimental.java b/src/main/java/rx/annotations/Experimental.java
index bc9a6bc259..dbcaaa3fe6 100644
--- a/src/main/java/rx/annotations/Experimental.java
+++ b/src/main/java/rx/annotations/Experimental.java
@@ -36,6 +36,5 @@
         ElementType.METHOD,
         ElementType.TYPE })
 @Documented
-@Experimental
 public @interface Experimental {
 }
\ No newline at end of file

From 2b47efee292099ea7f27a606a421e22aca76dc2e Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Wed, 28 Sep 2016 18:12:27 +1000
Subject: [PATCH 175/263] NotificationLite - reduce allocations (#4621)

---
 .../operators/BlockingOperatorMostRecent.java | 19 +++++----
 .../operators/BufferUntilSubscriber.java      | 12 +++---
 .../internal/operators/CachedObservable.java  | 22 +++++-----
 .../internal/operators/NotificationLite.java  | 35 +++++-----------
 .../operators/OnSubscribeCombineLatest.java   |  6 +--
 .../operators/OnSubscribeConcatMap.java       |  4 +-
 .../operators/OnSubscribeFlattenIterable.java |  7 +---
 .../OnSubscribeFromAsyncEmitter.java          | 14 ++-----
 .../operators/OnSubscribeFromEmitter.java     | 14 ++-----
 .../operators/OperatorEagerConcatMap.java     |  7 +---
 .../internal/operators/OperatorGroupBy.java   |  5 +--
 .../rx/internal/operators/OperatorMerge.java  | 11 ++---
 .../internal/operators/OperatorObserveOn.java |  7 +---
 .../OperatorOnBackpressureBuffer.java         |  5 +--
 .../internal/operators/OperatorPublish.java   | 19 ++++-----
 .../rx/internal/operators/OperatorReplay.java | 40 ++++++++-----------
 .../rx/internal/operators/OperatorScan.java   |  7 ++--
 .../internal/operators/OperatorSkipLast.java  |  6 +--
 .../rx/internal/operators/OperatorSwitch.java |  6 +--
 .../internal/operators/OperatorTakeLast.java  |  6 +--
 .../operators/OperatorTakeLastTimed.java      |  6 +--
 .../OperatorWindowWithObservable.java         | 12 +++---
 .../OperatorWindowWithObservableFactory.java  | 12 +++---
 .../operators/OperatorWindowWithTime.java     | 12 +++---
 .../java/rx/internal/util/RxRingBuffer.java   | 18 ++++-----
 .../rx/observables/BlockingObservable.java    | 18 ++++-----
 .../java/rx/observers/SerializedObserver.java |  9 ++---
 src/main/java/rx/subjects/AsyncSubject.java   | 34 ++++++++--------
 .../java/rx/subjects/BehaviorSubject.java     | 35 ++++++++--------
 .../subjects/SubjectSubscriptionManager.java  | 21 +++++-----
 src/main/java/rx/subjects/TestSubject.java    |  6 +--
 src/main/java/rx/subjects/UnicastSubject.java |  7 +---
 .../operators/NotificationLiteTest.java       | 36 ++++++++---------
 33 files changed, 194 insertions(+), 284 deletions(-)

diff --git a/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java b/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
index d7ceea9172..4ba6336f8e 100644
--- a/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
+++ b/src/main/java/rx/internal/operators/BlockingOperatorMostRecent.java
@@ -62,26 +62,25 @@ public Iterator<T> iterator() {
     }
 
     static final class MostRecentObserver<T> extends Subscriber<T> {
-        final NotificationLite<T> nl = NotificationLite.instance();
         volatile Object value;
 
         MostRecentObserver(T value) {
-            this.value = nl.next(value);
+            this.value = NotificationLite.next(value);
         }
 
         @Override
         public void onCompleted() {
-            value = nl.completed();
+            value = NotificationLite.completed();
         }
 
         @Override
         public void onError(Throwable e) {
-            value = nl.error(e);
+            value = NotificationLite.error(e);
         }
 
         @Override
         public void onNext(T args) {
-            value = nl.next(args);
+            value = NotificationLite.next(args);
         }
 
         /**
@@ -99,7 +98,7 @@ public Iterator<T> getIterable() {
                 @Override
                 public boolean hasNext() {
                     buf = value;
-                    return !nl.isCompleted(buf);
+                    return !NotificationLite.isCompleted(buf);
                 }
 
                 @Override
@@ -109,13 +108,13 @@ public T next() {
                         if (buf == null) {
                             buf = value;
                         }
-                        if (nl.isCompleted(buf)) {
+                        if (NotificationLite.isCompleted(buf)) {
                             throw new NoSuchElementException();
                         }
-                        if (nl.isError(buf)) {
-                            throw Exceptions.propagate(nl.getError(buf));
+                        if (NotificationLite.isError(buf)) {
+                            throw Exceptions.propagate(NotificationLite.getError(buf));
                         }
-                        return nl.getValue(buf);
+                        return NotificationLite.getValue(buf);
                     }
                     finally {
                         buf = null;
diff --git a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
index fc0001153c..2a4401c52c 100644
--- a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
+++ b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
@@ -71,7 +71,6 @@ static final class State<T> extends AtomicReference<Observer<? super T>> {
         boolean emitting;
 
         final ConcurrentLinkedQueue<Object> buffer = new ConcurrentLinkedQueue<Object>();
-        final NotificationLite<T> nl = NotificationLite.instance();
 
         boolean casObserverRef(Observer<? super T>  expected, Observer<? super T>  next) {
             return compareAndSet(expected, next);
@@ -103,11 +102,10 @@ public void call() {
                     }
                 }
                 if (win) {
-                    final NotificationLite<T> nl = NotificationLite.instance();
                     while(true) {
                         Object o;
                         while ((o = state.buffer.poll()) != null) {
-                            nl.accept(state.get(), o);
+                            NotificationLite.accept(state.get(), o);
                         }
                         synchronized (state.guard) {
                             if (state.buffer.isEmpty()) {
@@ -145,7 +143,7 @@ private void emit(Object v) {
         if (forward) {
             Object o;
             while ((o = state.buffer.poll()) != null) {
-                state.nl.accept(state.get(), o);
+                NotificationLite.accept(state.get(), o);
             }
             // Because `emit(Object v)` will be called in sequence,
             // no event will be put into `buffer` after we drain it.
@@ -158,7 +156,7 @@ public void onCompleted() {
             state.get().onCompleted();
         }
         else {
-            emit(state.nl.completed());
+            emit(NotificationLite.completed());
         }
     }
 
@@ -168,7 +166,7 @@ public void onError(Throwable e) {
             state.get().onError(e);
         }
         else {
-            emit(state.nl.error(e));
+            emit(NotificationLite.error(e));
         }
     }
 
@@ -178,7 +176,7 @@ public void onNext(T t) {
             state.get().onNext(t);
         }
         else {
-            emit(state.nl.next(t));
+            emit(NotificationLite.next(t));
         }
     }
 
diff --git a/src/main/java/rx/internal/operators/CachedObservable.java b/src/main/java/rx/internal/operators/CachedObservable.java
index 6f1f7598a2..f3b08676dd 100644
--- a/src/main/java/rx/internal/operators/CachedObservable.java
+++ b/src/main/java/rx/internal/operators/CachedObservable.java
@@ -102,8 +102,6 @@ static final class CacheState<T> extends LinkedArrayList implements Observer<T>
         /** The default empty array of producers. */
         static final ReplayProducer<?>[] EMPTY = new ReplayProducer<?>[0];
 
-        final NotificationLite<T> nl;
-
         /** Set to true after connection. */
         volatile boolean isConnected;
         /**
@@ -116,7 +114,6 @@ public CacheState(Observable<? extends T> source, int capacityHint) {
             super(capacityHint);
             this.source = source;
             this.producers = EMPTY;
-            this.nl = NotificationLite.instance();
             this.connection = new SerialSubscription();
         }
         /**
@@ -189,7 +186,7 @@ public void onCompleted() {
         @Override
         public void onNext(T t) {
             if (!sourceDone) {
-                Object o = nl.next(t);
+                Object o = NotificationLite.next(t);
                 add(o);
                 dispatch();
             }
@@ -198,7 +195,7 @@ public void onNext(T t) {
         public void onError(Throwable e) {
             if (!sourceDone) {
                 sourceDone = true;
-                Object o = nl.error(e);
+                Object o = NotificationLite.error(e);
                 add(o);
                 connection.unsubscribe();
                 dispatch();
@@ -208,7 +205,7 @@ public void onError(Throwable e) {
         public void onCompleted() {
             if (!sourceDone) {
                 sourceDone = true;
-                Object o = nl.completed();
+                Object o = NotificationLite.completed();
                 add(o);
                 connection.unsubscribe();
                 dispatch();
@@ -347,7 +344,6 @@ public void replay() {
             }
             boolean skipFinal = false;
             try {
-                final NotificationLite<T> nl = state.nl;
                 final Subscriber<? super T> child = this.child;
 
                 for (;;) {
@@ -376,14 +372,14 @@ public void replay() {
                         // eagerly emit any terminal event
                         if (r == 0) {
                             Object o = b[k];
-                            if (nl.isCompleted(o)) {
+                            if (NotificationLite.isCompleted(o)) {
                                 child.onCompleted();
                                 skipFinal = true;
                                 unsubscribe();
                                 return;
                             } else
-                            if (nl.isError(o)) {
-                                child.onError(nl.getError(o));
+                            if (NotificationLite.isError(o)) {
+                                child.onError(NotificationLite.getError(o));
                                 skipFinal = true;
                                 unsubscribe();
                                 return;
@@ -404,7 +400,7 @@ public void replay() {
                                 Object o = b[k];
 
                                 try {
-                                    if (nl.accept(child, o)) {
+                                    if (NotificationLite.accept(child, o)) {
                                         skipFinal = true;
                                         unsubscribe();
                                         return;
@@ -413,8 +409,8 @@ public void replay() {
                                     Exceptions.throwIfFatal(err);
                                     skipFinal = true;
                                     unsubscribe();
-                                    if (!nl.isError(o) && !nl.isCompleted(o)) {
-                                        child.onError(OnErrorThrowable.addValueAsLastCause(err, nl.getValue(o)));
+                                    if (!NotificationLite.isError(o) && !NotificationLite.isCompleted(o)) {
+                                        child.onError(OnErrorThrowable.addValueAsLastCause(err, NotificationLite.getValue(o)));
                                     }
                                     return;
                                 }
diff --git a/src/main/java/rx/internal/operators/NotificationLite.java b/src/main/java/rx/internal/operators/NotificationLite.java
index 205d0f556c..fad576e8e1 100644
--- a/src/main/java/rx/internal/operators/NotificationLite.java
+++ b/src/main/java/rx/internal/operators/NotificationLite.java
@@ -34,24 +34,11 @@
  * @param <T> the element type
  */
 public final class NotificationLite<T> {
-    @SuppressWarnings("rawtypes")
-    private static final NotificationLite INSTANCE = new NotificationLite();
 
     private NotificationLite() {
         // singleton
     }
 
-    /**
-     * Gets the {@code NotificationLite} singleton.
-     *
-     * @param <T> the value type
-     * @return the sole {@code NotificationLite} object
-     */
-    @SuppressWarnings("unchecked")
-    public static <T> NotificationLite<T> instance() {
-        return INSTANCE;
-    }
-
     private static final Object ON_COMPLETED_SENTINEL = new Serializable() {
         private static final long serialVersionUID = 1;
 
@@ -92,7 +79,7 @@ public String toString() {
      *          the item emitted to {@code onNext}
      * @return the item, or a null token representing the item if the item is {@code null}
      */
-    public Object next(T t) {
+    public static <T> Object next(T t) {
         if (t == null) {
             return ON_NEXT_NULL_SENTINEL;
         } else {
@@ -106,7 +93,7 @@ public Object next(T t) {
      *
      * @return a completion token
      */
-    public Object completed() {
+    public static Object completed() {
         return ON_COMPLETED_SENTINEL;
     }
 
@@ -119,7 +106,7 @@ public Object completed() {
      *           the {@code Throwable} in the {@code onError} notification
      * @return an object encapsulating the exception
      */
-    public Object error(Throwable e) {
+    public static Object error(Throwable e) {
         return new OnErrorSentinel(e);
     }
 
@@ -137,7 +124,7 @@ public Object error(Throwable e) {
      *             if the {@link Observer} is null.
      */
     @SuppressWarnings("unchecked")
-    public boolean accept(Observer<? super T> o, Object n) {
+    public static <T> boolean accept(Observer<? super T> o, Object n) {
         if (n == ON_COMPLETED_SENTINEL) {
             o.onCompleted();
             return true;
@@ -163,7 +150,7 @@ public boolean accept(Observer<? super T> o, Object n) {
      *            the lite notification
      * @return {@code true} if {@code n} represents an {@code onCompleted} event; {@code false} otherwise
      */
-    public boolean isCompleted(Object n) {
+    public static boolean isCompleted(Object n) {
         return n == ON_COMPLETED_SENTINEL;
     }
 
@@ -174,7 +161,7 @@ public boolean isCompleted(Object n) {
      *            the lite notification
      * @return {@code true} if {@code n} represents an {@code onError} event; {@code false} otherwise
      */
-    public boolean isError(Object n) {
+    public static boolean isError(Object n) {
         return n instanceof OnErrorSentinel;
     }
 
@@ -183,7 +170,7 @@ public boolean isError(Object n) {
      * @param n the lite notification
      * @return {@code true} if {@code n} represents a wrapped {@code null} {@code onNext} event, {@code false} otherwise
      */
-    public boolean isNull(Object n) {
+    public static boolean isNull(Object n) {
         return n == ON_NEXT_NULL_SENTINEL;
     }
 
@@ -192,7 +179,7 @@ public boolean isNull(Object n) {
      * @param n the lite notification
      * @return {@code true} if {@code n} represents an {@code onNext} event, {@code false} otherwise
      */
-    public boolean isNext(Object n) {
+    public static boolean isNext(Object n) {
         return n != null && !isError(n) && !isCompleted(n);
     }
     /**
@@ -207,7 +194,7 @@ public boolean isNext(Object n) {
      * @return the {@link Kind} of lite notification {@code n} is: either {@code Kind.OnCompleted},
      *         {@code Kind.OnError}, or {@code Kind.OnNext}
      */
-    public Kind kind(Object n) {
+    public static Kind kind(Object n) {
         if (n == null) {
             throw new IllegalArgumentException("The lite notification can not be null");
         } else if (n == ON_COMPLETED_SENTINEL) {
@@ -230,7 +217,7 @@ public Kind kind(Object n) {
      * @return the unwrapped value, which can be null
      */
     @SuppressWarnings("unchecked")
-    public T getValue(Object n) {
+    public static <T> T getValue(Object n) {
         return n == ON_NEXT_NULL_SENTINEL ? null : (T) n;
     }
 
@@ -243,7 +230,7 @@ public T getValue(Object n) {
      *            the lite notification (of type {@code Kind.OnError})
      * @return the {@link Throwable} wrapped inside {@code n}
      */
-    public Throwable getError(Object n) {
+    public static Throwable getError(Object n) {
         return ((OnErrorSentinel) n).e;
     }
 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
index ef5bca4951..d7f576bfae 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeCombineLatest.java
@@ -202,7 +202,7 @@ void combine(Object value, int index) {
                 if (value == null) {
                     complete = ++completedCount;
                 } else {
-                    latest[index] = combinerSubscriber.nl.getValue(value);
+                    latest[index] = NotificationLite.getValue(value);
                 }
                 allSourcesFinished = activeCount == sourceCount;
                 // see if either all sources completed
@@ -358,14 +358,12 @@ void onError(Throwable e) {
     static final class CombinerSubscriber<T, R> extends Subscriber<T> {
         final LatestCoordinator<T, R> parent;
         final int index;
-        final NotificationLite<T> nl;
 
         boolean done;
 
         public CombinerSubscriber(LatestCoordinator<T, R> parent, int index) {
             this.parent = parent;
             this.index = index;
-            this.nl = NotificationLite.instance();
             request(parent.bufferSize);
         }
 
@@ -374,7 +372,7 @@ public void onNext(T t) {
             if (done) {
                 return;
             }
-            parent.combine(nl.next(t), index);
+            parent.combine(NotificationLite.next(t), index);
         }
 
         @Override
diff --git a/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java b/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java
index c12643f123..befcb2761a 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeConcatMap.java
@@ -137,7 +137,7 @@ public ConcatMapSubscriber(Subscriber<? super R> actual,
 
         @Override
         public void onNext(T t) {
-            if (!queue.offer(NotificationLite.instance().next(t))) {
+            if (!queue.offer(NotificationLite.next(t))) {
                 unsubscribe();
                 onError(new MissingBackpressureException());
             } else {
@@ -256,7 +256,7 @@ void drain() {
                         Observable<? extends R> source;
 
                         try {
-                            source = mapper.call(NotificationLite.<T>instance().getValue(v));
+                            source = mapper.call(NotificationLite.<T>getValue(v));
                         } catch (Throwable mapperError) {
                             Exceptions.throwIfFatal(mapperError);
                             drainError(mapperError);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
index f426a970d1..608e6808b7 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
@@ -90,8 +90,6 @@ static final class FlattenIterableSubscriber<T, R> extends Subscriber<T> {
 
         final AtomicInteger wip;
 
-        final NotificationLite<T> nl;
-
         volatile boolean done;
 
         long produced;
@@ -105,7 +103,6 @@ public FlattenIterableSubscriber(Subscriber<? super R> actual,
             this.error = new AtomicReference<Throwable>();
             this.wip = new AtomicInteger();
             this.requested = new AtomicLong();
-            this.nl = NotificationLite.instance();
             if (prefetch == Integer.MAX_VALUE) {
                 this.limit = Long.MAX_VALUE;
                 this.queue = new SpscLinkedArrayQueue<Object>(RxRingBuffer.SIZE);
@@ -123,7 +120,7 @@ public FlattenIterableSubscriber(Subscriber<? super R> actual,
 
         @Override
         public void onNext(T t) {
-            if (!queue.offer(nl.next(t))) {
+            if (!queue.offer(NotificationLite.next(t))) {
                 unsubscribe();
                 onError(new MissingBackpressureException());
                 return;
@@ -194,7 +191,7 @@ void drain() {
                         boolean b;
 
                         try {
-                            Iterable<? extends R> iterable = mapper.call(nl.getValue(v));
+                            Iterable<? extends R> iterable = mapper.call(NotificationLite.<T>getValue(v));
 
                             it = iterable.iterator();
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java b/src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java
index d3f5867254..0a10841183 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java
@@ -320,20 +320,17 @@ static final class BufferAsyncEmitter<T> extends BaseAsyncEmitter<T> {
 
         final AtomicInteger wip;
 
-        final NotificationLite<T> nl;
-
         public BufferAsyncEmitter(Subscriber<? super T> actual, int capacityHint) {
             super(actual);
             this.queue = UnsafeAccess.isUnsafeAvailable()
                     ? new SpscUnboundedArrayQueue<Object>(capacityHint)
                     : new SpscUnboundedAtomicArrayQueue<Object>(capacityHint);
             this.wip = new AtomicInteger();
-            this.nl = NotificationLite.instance();
         }
 
         @Override
         public void onNext(T t) {
-            queue.offer(nl.next(t));
+            queue.offer(NotificationLite.next(t));
             drain();
         }
 
@@ -401,7 +398,7 @@ void drain() {
                         break;
                     }
 
-                    a.onNext(nl.getValue(o));
+                    a.onNext(NotificationLite.<T>getValue(o));
 
                     e++;
                 }
@@ -451,18 +448,15 @@ static final class LatestAsyncEmitter<T> extends BaseAsyncEmitter<T> {
 
         final AtomicInteger wip;
 
-        final NotificationLite<T> nl;
-
         public LatestAsyncEmitter(Subscriber<? super T> actual) {
             super(actual);
             this.queue = new AtomicReference<Object>();
             this.wip = new AtomicInteger();
-            this.nl = NotificationLite.instance();
         }
 
         @Override
         public void onNext(T t) {
-            queue.set(nl.next(t));
+            queue.set(NotificationLite.next(t));
             drain();
         }
 
@@ -530,7 +524,7 @@ void drain() {
                         break;
                     }
 
-                    a.onNext(nl.getValue(o));
+                    a.onNext(NotificationLite.<T>getValue(o));
 
                     e++;
                 }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java b/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
index cfed34fc25..2cfec566d4 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
@@ -320,20 +320,17 @@ static final class BufferEmitter<T> extends BaseEmitter<T> {
 
         final AtomicInteger wip;
 
-        final NotificationLite<T> nl;
-
         public BufferEmitter(Subscriber<? super T> actual, int capacityHint) {
             super(actual);
             this.queue = UnsafeAccess.isUnsafeAvailable()
                     ? new SpscUnboundedArrayQueue<Object>(capacityHint)
                     : new SpscUnboundedAtomicArrayQueue<Object>(capacityHint);
             this.wip = new AtomicInteger();
-            this.nl = NotificationLite.instance();
         }
 
         @Override
         public void onNext(T t) {
-            queue.offer(nl.next(t));
+            queue.offer(NotificationLite.next(t));
             drain();
         }
 
@@ -401,7 +398,7 @@ void drain() {
                         break;
                     }
 
-                    a.onNext(nl.getValue(o));
+                    a.onNext(NotificationLite.<T>getValue(o));
 
                     e++;
                 }
@@ -451,18 +448,15 @@ static final class LatestEmitter<T> extends BaseEmitter<T> {
 
         final AtomicInteger wip;
 
-        final NotificationLite<T> nl;
-
         public LatestEmitter(Subscriber<? super T> actual) {
             super(actual);
             this.queue = new AtomicReference<Object>();
             this.wip = new AtomicInteger();
-            this.nl = NotificationLite.instance();
         }
 
         @Override
         public void onNext(T t) {
-            queue.set(nl.next(t));
+            queue.set(NotificationLite.next(t));
             drain();
         }
 
@@ -530,7 +524,7 @@ void drain() {
                         break;
                     }
 
-                    a.onNext(nl.getValue(o));
+                    a.onNext(NotificationLite.<T>getValue(o));
 
                     e++;
                 }
diff --git a/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java b/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java
index c16dbcdbdc..c6d4c29c25 100644
--- a/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java
+++ b/src/main/java/rx/internal/operators/OperatorEagerConcatMap.java
@@ -171,7 +171,6 @@ void drain() {
 
             final AtomicLong requested = sharedProducer;
             final Subscriber<? super R> actualSubscriber = this.actual;
-            final NotificationLite<R> nl = NotificationLite.instance();
 
             for (;;) {
 
@@ -243,7 +242,7 @@ void drain() {
                         innerQueue.poll();
 
                         try {
-                            actualSubscriber.onNext(nl.getValue(v));
+                            actualSubscriber.onNext(NotificationLite.<R>getValue(v));
                         } catch (Throwable ex) {
                             Exceptions.throwOrReport(ex, actualSubscriber, v);
                             return;
@@ -277,7 +276,6 @@ void drain() {
     static final class EagerInnerSubscriber<T> extends Subscriber<T> {
         final EagerOuterSubscriber<?, T> parent;
         final Queue<Object> queue;
-        final NotificationLite<T> nl;
 
         volatile boolean done;
         Throwable error;
@@ -292,13 +290,12 @@ public EagerInnerSubscriber(EagerOuterSubscriber<?, T> parent, int bufferSize) {
                 q = new SpscAtomicArrayQueue<Object>(bufferSize);
             }
             this.queue = q;
-            this.nl = NotificationLite.instance();
             request(bufferSize);
         }
 
         @Override
         public void onNext(T t) {
-            queue.offer(nl.next(t));
+            queue.offer(NotificationLite.next(t));
             parent.drain();
         }
 
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index b0f81db64c..abbe5cf3cf 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -493,7 +493,7 @@ public void onNext(T t) {
                 error = new NullPointerException();
                 done = true;
             } else {
-                queue.offer(NotificationLite.instance().next(t));
+                queue.offer(NotificationLite.next(t));
             }
             drain();
         }
@@ -518,7 +518,6 @@ void drain() {
             final Queue<Object> q = queue;
             final boolean delayError = this.delayError;
             Subscriber<? super T> a = actual.get();
-            NotificationLite<T> nl = NotificationLite.instance();
             for (;;) {
                 if (a != null) {
                     if (checkTerminated(done, q.isEmpty(), a, delayError)) {
@@ -541,7 +540,7 @@ void drain() {
                             break;
                         }
 
-                        a.onNext(nl.getValue(v));
+                        a.onNext(NotificationLite.<T>getValue(v));
 
                         e++;
                     }
diff --git a/src/main/java/rx/internal/operators/OperatorMerge.java b/src/main/java/rx/internal/operators/OperatorMerge.java
index 0e67131f13..fa30f46b10 100644
--- a/src/main/java/rx/internal/operators/OperatorMerge.java
+++ b/src/main/java/rx/internal/operators/OperatorMerge.java
@@ -159,8 +159,6 @@ static final class MergeSubscriber<T> extends Subscriber<Observable<? extends T>
         /** Due to the emission loop, we need to store errors somewhere if !delayErrors. */
         volatile ConcurrentLinkedQueue<Throwable> errors;
 
-        final NotificationLite<T> nl;
-
         volatile boolean done;
 
         /** Guarded by this. */
@@ -191,7 +189,6 @@ public MergeSubscriber(Subscriber<? super T> child, boolean delayErrors, int max
             this.child = child;
             this.delayErrors = delayErrors;
             this.maxConcurrent = maxConcurrent;
-            this.nl = NotificationLite.instance();
             this.innerGuard = new Object();
             this.innerSubscribers = EMPTY;
             if (maxConcurrent == Integer.MAX_VALUE) {
@@ -379,7 +376,7 @@ protected void queueScalar(InnerSubscriber<T> subscriber, T value) {
                 subscriber.queue = q;
             }
             try {
-                q.onNext(nl.next(value));
+                q.onNext(NotificationLite.next(value));
             } catch (MissingBackpressureException ex) {
                 subscriber.unsubscribe();
                 subscriber.onError(ex);
@@ -501,7 +498,7 @@ protected void queueScalar(T value) {
                 }
                 this.queue = q;
             }
-            if (!q.offer(nl.next(value))) {
+            if (!q.offer(NotificationLite.next(value))) {
                 unsubscribe();
                 onError(OnErrorThrowable.addValueAsLastCause(new MissingBackpressureException(), value));
             }
@@ -606,7 +603,7 @@ void emitLoop() {
                                 if (o == null) {
                                     break;
                                 }
-                                T v = nl.getValue(o);
+                                T v = NotificationLite.getValue(o);
                                 // if child throws, report bounce it back immediately
                                 try {
                                     child.onNext(v);
@@ -723,7 +720,7 @@ void emitLoop() {
                                     if (o == null) {
                                         break;
                                     }
-                                    T v = nl.getValue(o);
+                                    T v = NotificationLite.getValue(o);
                                     // if child throws, report bounce it back immediately
                                     try {
                                         child.onNext(v);
diff --git a/src/main/java/rx/internal/operators/OperatorObserveOn.java b/src/main/java/rx/internal/operators/OperatorObserveOn.java
index b037758478..351cb35aca 100644
--- a/src/main/java/rx/internal/operators/OperatorObserveOn.java
+++ b/src/main/java/rx/internal/operators/OperatorObserveOn.java
@@ -92,7 +92,6 @@ public Subscriber<? super T> call(Subscriber<? super T> child) {
     static final class ObserveOnSubscriber<T> extends Subscriber<T> implements Action0 {
         final Subscriber<? super T> child;
         final Scheduler.Worker recursiveScheduler;
-        final NotificationLite<T> on;
         final boolean delayError;
         final Queue<Object> queue;
         /** The emission threshold that should trigger a replenishing request. */
@@ -120,7 +119,6 @@ public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> child, boo
             this.child = child;
             this.recursiveScheduler = scheduler.createWorker();
             this.delayError = delayError;
-            this.on = NotificationLite.instance();
             int calculatedSize = (bufferSize > 0) ? bufferSize : RxRingBuffer.SIZE;
             // this formula calculates the 75% of the bufferSize, rounded up to the next integer
             this.limit = calculatedSize - (calculatedSize >> 2);
@@ -158,7 +156,7 @@ public void onNext(final T t) {
             if (isUnsubscribed() || finished) {
                 return;
             }
-            if (!queue.offer(on.next(t))) {
+            if (!queue.offer(NotificationLite.next(t))) {
                 onError(new MissingBackpressureException());
                 return;
             }
@@ -202,7 +200,6 @@ public void call() {
             // of the constant fields
             final Queue<Object> q = this.queue;
             final Subscriber<? super T> localChild = this.child;
-            final NotificationLite<T> localOn = this.on;
 
             // requested and counter are not included to avoid JIT issues with register spilling
             // and their access is is amortized because they are part of the outer loop which runs
@@ -224,7 +221,7 @@ public void call() {
                         break;
                     }
 
-                    localChild.onNext(localOn.getValue(v));
+                    localChild.onNext(NotificationLite.<T>getValue(v));
 
                     currentEmission++;
                     if (currentEmission == limit) {
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
index c93e5756b1..f47c39b125 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureBuffer.java
@@ -111,7 +111,6 @@ static final class BufferSubscriber<T> extends Subscriber<T> implements Backpres
         private final Subscriber<? super T> child;
         private final AtomicBoolean saturated = new AtomicBoolean(false);
         private final BackpressureDrainManager manager;
-        private final NotificationLite<T> on = NotificationLite.instance();
         private final Action0 onOverflow;
         private final Strategy overflowStrategy;
 
@@ -148,13 +147,13 @@ public void onNext(T t) {
             if (!assertCapacity()) {
                 return;
             }
-            queue.offer(on.next(t));
+            queue.offer(NotificationLite.next(t));
             manager.drain();
         }
 
         @Override
         public boolean accept(Object value) {
-            return on.accept(child, value);
+            return NotificationLite.accept(child, value);
         }
         @Override
         public void complete(Throwable exception) {
diff --git a/src/main/java/rx/internal/operators/OperatorPublish.java b/src/main/java/rx/internal/operators/OperatorPublish.java
index 29ebd80149..f7879a7ee1 100644
--- a/src/main/java/rx/internal/operators/OperatorPublish.java
+++ b/src/main/java/rx/internal/operators/OperatorPublish.java
@@ -96,10 +96,10 @@ public void call(Subscriber<? super T> child) {
                      * subscribers as well:
                      *
                      * Object term = r.terminalEvent;
-                     * if (r.nl.isCompleted(term)) {
+                     * if (NotificationLite.isCompleted(term)) {
                      *     child.onCompleted();
                      * } else {
-                     *     child.onError(r.nl.getError(term));
+                     *     child.onError(NotificationLite.getError(term));
                      * }
                      * return;
                      *
@@ -218,8 +218,6 @@ public void connect(Action1<? super Subscription> connection) {
     static final class PublishSubscriber<T> extends Subscriber<T> implements Subscription {
         /** Holds notifications from upstream. */
         final Queue<Object> queue;
-        /** The notification-lite factory. */
-        final NotificationLite<T> nl;
         /** Holds onto the current connected PublishSubscriber. */
         final AtomicReference<PublishSubscriber<T>> current;
         /** Contains either an onCompleted or an onError token from upstream. */
@@ -248,7 +246,6 @@ public PublishSubscriber(AtomicReference<PublishSubscriber<T>> current) {
                     ? new SpscArrayQueue<Object>(RxRingBuffer.SIZE)
                     : new SynchronizedQueue<Object>(RxRingBuffer.SIZE);
 
-            this.nl = NotificationLite.instance();
             this.producers = new AtomicReference<InnerProducer[]>(EMPTY);
             this.current = current;
             this.shouldConnect = new AtomicBoolean();
@@ -277,7 +274,7 @@ public void onStart() {
         public void onNext(T t) {
             // we expect upstream to honor backpressure requests
             // nl is required because JCTools queue doesn't accept nulls.
-            if (!queue.offer(nl.next(t))) {
+            if (!queue.offer(NotificationLite.next(t))) {
                 onError(new MissingBackpressureException());
             } else {
                 // since many things can happen concurrently, we have a common dispatch
@@ -290,7 +287,7 @@ public void onError(Throwable e) {
             // The observer front is accessed serially as required by spec so
             // no need to CAS in the terminal value
             if (terminalEvent == null) {
-                terminalEvent = nl.error(e);
+                terminalEvent = NotificationLite.error(e);
                 // since many things can happen concurrently, we have a common dispatch
                 // loop to act on the current state serially
                 dispatch();
@@ -301,7 +298,7 @@ public void onCompleted() {
             // The observer front is accessed serially as required by spec so
             // no need to CAS in the terminal value
             if (terminalEvent == null) {
-                terminalEvent = nl.completed();
+                terminalEvent = NotificationLite.completed();
                 // since many things can happen concurrently, we have a common dispatch loop
                 // to act on the current state serially
                 dispatch();
@@ -402,7 +399,7 @@ boolean checkTerminated(Object term, boolean empty) {
             // first of all, check if there is actually a terminal event
             if (term != null) {
                 // is it a completion event (impl. note, this is much cheaper than checking for isError)
-                if (nl.isCompleted(term)) {
+                if (NotificationLite.isCompleted(term)) {
                     // but we also need to have an empty queue
                     if (empty) {
                         // this will prevent OnSubscribe spinning on a terminated but
@@ -433,7 +430,7 @@ boolean checkTerminated(Object term, boolean empty) {
                         return true;
                     }
                 } else {
-                    Throwable t = nl.getError(term);
+                    Throwable t = NotificationLite.getError(term);
                     // this will prevent OnSubscribe spinning on a terminated
                     // but not yet unsubscribed PublishSubscriber
                     current.compareAndSet(this, null);
@@ -575,7 +572,7 @@ void dispatch() {
                                 break;
                             }
                             // we need to unwrap potential nulls
-                            T value = nl.getValue(v);
+                            T value = NotificationLite.getValue(v);
                             // let's emit this value to all child subscribers
                             for (InnerProducer<T> ip : ps) {
                                 // if ip.get() is negative, the child has either unsubscribed in the
diff --git a/src/main/java/rx/internal/operators/OperatorReplay.java b/src/main/java/rx/internal/operators/OperatorReplay.java
index 617656378d..53511f9c80 100644
--- a/src/main/java/rx/internal/operators/OperatorReplay.java
+++ b/src/main/java/rx/internal/operators/OperatorReplay.java
@@ -304,8 +304,6 @@ public void connect(Action1<? super Subscription> connection) {
     static final class ReplaySubscriber<T> extends Subscriber<T> implements Subscription {
         /** Holds notifications from upstream. */
         final ReplayBuffer<T> buffer;
-        /** The notification-lite factory. */
-        final NotificationLite<T> nl;
         /** Contains either an onCompleted or an onError token from upstream. */
         boolean done;
 
@@ -351,8 +349,6 @@ static final class ReplaySubscriber<T> extends Subscriber<T> implements Subscrip
         @SuppressWarnings("unchecked")
         public ReplaySubscriber(ReplayBuffer<T> buffer) {
             this.buffer = buffer;
-
-            this.nl = NotificationLite.instance();
             this.producers = new OpenHashSet<InnerProducer<T>>();
             this.producersCache = EMPTY;
             this.shouldConnect = new AtomicBoolean();
@@ -840,29 +836,27 @@ interface ReplayBuffer<T> {
     static final class UnboundedReplayBuffer<T> extends ArrayList<Object> implements ReplayBuffer<T> {
         /** */
         private static final long serialVersionUID = 7063189396499112664L;
-        final NotificationLite<T> nl;
         /** The total number of events in the buffer. */
         volatile int size;
 
         public UnboundedReplayBuffer(int capacityHint) {
             super(capacityHint);
-            nl = NotificationLite.instance();
         }
         @Override
         public void next(T value) {
-            add(nl.next(value));
+            add(NotificationLite.next(value));
             size++;
         }
 
         @Override
         public void error(Throwable e) {
-            add(nl.error(e));
+            add(NotificationLite.error(e));
             size++;
         }
 
         @Override
         public void complete() {
-            add(nl.completed());
+            add(NotificationLite.completed());
             size++;
         }
 
@@ -895,14 +889,14 @@ public void replay(InnerProducer<T> output) {
                 while (e != r && destinationIndex < sourceIndex) {
                     Object o = get(destinationIndex);
                     try {
-                        if (nl.accept(child, o)) {
+                        if (NotificationLite.accept(child, o)) {
                             return;
                         }
                     } catch (Throwable err) {
                         Exceptions.throwIfFatal(err);
                         output.unsubscribe();
-                        if (!nl.isError(o) && !nl.isCompleted(o)) {
-                            child.onError(OnErrorThrowable.addValueAsLastCause(err, nl.getValue(o)));
+                        if (!NotificationLite.isError(o) && !NotificationLite.isCompleted(o)) {
+                            child.onError(OnErrorThrowable.addValueAsLastCause(err, NotificationLite.getValue(o)));
                         }
                         return;
                     }
@@ -957,7 +951,6 @@ public Node(Object value, long index) {
     static class BoundedReplayBuffer<T> extends AtomicReference<Node> implements ReplayBuffer<T> {
         /** */
         private static final long serialVersionUID = 2346567790059478686L;
-        final NotificationLite<T> nl;
 
         Node tail;
         int size;
@@ -966,7 +959,6 @@ static class BoundedReplayBuffer<T> extends AtomicReference<Node> implements Rep
         long index;
 
         public BoundedReplayBuffer() {
-            nl = NotificationLite.instance();
             Node n = new Node(null, 0);
             tail = n;
             set(n);
@@ -1025,7 +1017,7 @@ Node getInitialHead() {
 
         @Override
         public final void next(T value) {
-            Object o = enterTransform(nl.next(value));
+            Object o = enterTransform(NotificationLite.next(value));
             Node n = new Node(o, ++index);
             addLast(n);
             truncate();
@@ -1033,7 +1025,7 @@ public final void next(T value) {
 
         @Override
         public final void error(Throwable e) {
-            Object o = enterTransform(nl.error(e));
+            Object o = enterTransform(NotificationLite.error(e));
             Node n = new Node(o, ++index);
             addLast(n);
             truncateFinal();
@@ -1041,7 +1033,7 @@ public final void error(Throwable e) {
 
         @Override
         public final void complete() {
-            Object o = enterTransform(nl.completed());
+            Object o = enterTransform(NotificationLite.completed());
             Node n = new Node(o, ++index);
             addLast(n);
             truncateFinal();
@@ -1090,7 +1082,7 @@ public final void replay(InnerProducer<T> output) {
                     if (v != null) {
                         Object o = leaveTransform(v.value);
                         try {
-                            if (nl.accept(child, o)) {
+                            if (NotificationLite.accept(child, o)) {
                                 output.index = null;
                                 return;
                             }
@@ -1098,8 +1090,8 @@ public final void replay(InnerProducer<T> output) {
                             output.index = null;
                             Exceptions.throwIfFatal(err);
                             output.unsubscribe();
-                            if (!nl.isError(o) && !nl.isCompleted(o)) {
-                                child.onError(OnErrorThrowable.addValueAsLastCause(err, nl.getValue(o)));
+                            if (!NotificationLite.isError(o) && !NotificationLite.isCompleted(o)) {
+                                child.onError(OnErrorThrowable.addValueAsLastCause(err, NotificationLite.getValue(o)));
                             }
                             return;
                         }
@@ -1171,10 +1163,10 @@ void truncateFinal() {
                 if (next != null) {
                     Object o = next.value;
                     Object v = leaveTransform(o);
-                    if (nl.isCompleted(v) || nl.isError(v)) {
+                    if (NotificationLite.isCompleted(v) || NotificationLite.isError(v)) {
                         break;
                     }
-                    output.add(nl.getValue(v));
+                    output.add(NotificationLite.<T>getValue(v));
                     n = next;
                 } else {
                     break;
@@ -1182,10 +1174,10 @@ void truncateFinal() {
             }
         }
         /* test */ boolean hasError() {
-            return tail.value != null && nl.isError(leaveTransform(tail.value));
+            return tail.value != null && NotificationLite.isError(leaveTransform(tail.value));
         }
         /* test */ boolean hasCompleted() {
-            return tail.value != null && nl.isCompleted(leaveTransform(tail.value));
+            return tail.value != null && NotificationLite.isCompleted(leaveTransform(tail.value));
         }
     }
 
diff --git a/src/main/java/rx/internal/operators/OperatorScan.java b/src/main/java/rx/internal/operators/OperatorScan.java
index d3cbf8bc52..4f0e2d1e12 100644
--- a/src/main/java/rx/internal/operators/OperatorScan.java
+++ b/src/main/java/rx/internal/operators/OperatorScan.java
@@ -192,13 +192,13 @@ public InitialProducer(R initialValue, Subscriber<? super R> child) {
                 q = new SpscLinkedAtomicQueue<Object>();  // new SpscUnboundedAtomicArrayQueue<R>(8);
             }
             this.queue = q;
-            q.offer(NotificationLite.instance().next(initialValue));
+            q.offer(NotificationLite.next(initialValue));
             this.requested = new AtomicLong();
         }
 
         @Override
         public void onNext(R t) {
-            queue.offer(NotificationLite.instance().next(t));
+            queue.offer(NotificationLite.next(t));
             emit();
         }
 
@@ -298,7 +298,6 @@ void emit() {
         void emitLoop() {
             final Subscriber<? super R> child = this.child;
             final Queue<Object> queue = this.queue;
-            final NotificationLite<R> nl = NotificationLite.instance();
             AtomicLong requested = this.requested;
 
             long r = requested.get();
@@ -319,7 +318,7 @@ void emitLoop() {
                     if (empty) {
                         break;
                     }
-                    R v = nl.getValue(o);
+                    R v = NotificationLite.getValue(o);
                     try {
                         child.onNext(v);
                     } catch (Throwable ex) {
diff --git a/src/main/java/rx/internal/operators/OperatorSkipLast.java b/src/main/java/rx/internal/operators/OperatorSkipLast.java
index 1dd412e94a..de5acf1349 100644
--- a/src/main/java/rx/internal/operators/OperatorSkipLast.java
+++ b/src/main/java/rx/internal/operators/OperatorSkipLast.java
@@ -39,8 +39,6 @@ public OperatorSkipLast(int count) {
     public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
         return new Subscriber<T>(subscriber) {
 
-            private final NotificationLite<T> on = NotificationLite.instance();
-
             /**
              * Store the last count elements until now.
              */
@@ -66,11 +64,11 @@ public void onNext(T value) {
                     return;
                 }
                 if (deque.size() == count) {
-                    subscriber.onNext(on.getValue(deque.removeFirst()));
+                    subscriber.onNext(NotificationLite.<T>getValue(deque.removeFirst()));
                 } else {
                     request(1);
                 }
-                deque.offerLast(on.next(value));
+                deque.offerLast(NotificationLite.next(value));
             }
 
         };
diff --git a/src/main/java/rx/internal/operators/OperatorSwitch.java b/src/main/java/rx/internal/operators/OperatorSwitch.java
index 3bf96dca11..1f2806ab53 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitch.java
+++ b/src/main/java/rx/internal/operators/OperatorSwitch.java
@@ -80,7 +80,6 @@ static final class SwitchSubscriber<T> extends Subscriber<Observable<? extends T
         final boolean delayError;
         final AtomicLong index;
         final SpscLinkedArrayQueue<Object> queue;
-        final NotificationLite<T> nl;
 
         boolean emitting;
 
@@ -104,7 +103,6 @@ static final class SwitchSubscriber<T> extends Subscriber<Observable<? extends T
             this.delayError = delayError;
             this.index = new AtomicLong();
             this.queue = new SpscLinkedArrayQueue<Object>(RxRingBuffer.SIZE);
-            this.nl = NotificationLite.instance();
         }
 
         void init() {
@@ -202,7 +200,7 @@ void emit(T value, InnerSubscriber<T> inner) {
                     return;
                 }
 
-                queue.offer(inner, nl.next(value));
+                queue.offer(inner, NotificationLite.next(value));
             }
             drain();
         }
@@ -310,7 +308,7 @@ void drain() {
 
                     @SuppressWarnings("unchecked")
                     InnerSubscriber<T> inner = (InnerSubscriber<T>)localQueue.poll();
-                    T value = nl.getValue(localQueue.poll());
+                    T value = NotificationLite.getValue(localQueue.poll());
 
                     if (localIndex.get() == inner.id) {
                         localChild.onNext(value);
diff --git a/src/main/java/rx/internal/operators/OperatorTakeLast.java b/src/main/java/rx/internal/operators/OperatorTakeLast.java
index 6767484677..d25d06be3d 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeLast.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeLast.java
@@ -60,14 +60,12 @@ static final class TakeLastSubscriber<T> extends Subscriber<T> implements Func1<
         final AtomicLong requested;
         final ArrayDeque<Object> queue;
         final int count;
-        final NotificationLite<T> nl;
 
         public TakeLastSubscriber(Subscriber<? super T> actual, int count) {
             this.actual = actual;
             this.count = count;
             this.requested = new AtomicLong();
             this.queue = new ArrayDeque<Object>();
-            this.nl = NotificationLite.instance();
         }
 
         @Override
@@ -75,7 +73,7 @@ public void onNext(T t) {
             if (queue.size() == count) {
                 queue.poll();
             }
-            queue.offer(nl.next(t));
+            queue.offer(NotificationLite.next(t));
         }
 
         @Override
@@ -91,7 +89,7 @@ public void onCompleted() {
 
         @Override
         public T call(Object t) {
-            return nl.getValue(t);
+            return NotificationLite.getValue(t);
         }
 
         void requestMore(long n) {
diff --git a/src/main/java/rx/internal/operators/OperatorTakeLastTimed.java b/src/main/java/rx/internal/operators/OperatorTakeLastTimed.java
index e4a35922ad..b05e6e77aa 100644
--- a/src/main/java/rx/internal/operators/OperatorTakeLastTimed.java
+++ b/src/main/java/rx/internal/operators/OperatorTakeLastTimed.java
@@ -74,7 +74,6 @@ static final class TakeLastTimedSubscriber<T> extends Subscriber<T> implements F
         final AtomicLong requested;
         final ArrayDeque<Object> queue;
         final ArrayDeque<Long> queueTimes;
-        final NotificationLite<T> nl;
 
         public TakeLastTimedSubscriber(Subscriber<? super T> actual, int count, long ageMillis, Scheduler scheduler) {
             this.actual = actual;
@@ -84,7 +83,6 @@ public TakeLastTimedSubscriber(Subscriber<? super T> actual, int count, long age
             this.requested = new AtomicLong();
             this.queue = new ArrayDeque<Object>();
             this.queueTimes = new ArrayDeque<Long>();
-            this.nl = NotificationLite.instance();
         }
 
         @Override
@@ -99,7 +97,7 @@ public void onNext(T t) {
 
                 evictOld(now);
 
-                queue.offer(nl.next(t));
+                queue.offer(NotificationLite.next(t));
                 queueTimes.offer(now);
             }
         }
@@ -134,7 +132,7 @@ public void onCompleted() {
 
         @Override
         public T call(Object t) {
-            return nl.getValue(t);
+            return NotificationLite.getValue(t);
         }
 
         void requestMore(long n) {
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java b/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
index 4849f162d8..47b0e3be59 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithObservable.java
@@ -35,8 +35,6 @@ public final class OperatorWindowWithObservable<T, U> implements Operator<Observ
     final Observable<U> other;
     /** Indicate the current subject should complete and a new subject be emitted. */
     static final Object NEXT_SUBJECT = new Object();
-    /** For error and completion indication. */
-    static final NotificationLite<Object> NL = NotificationLite.instance();
 
     public OperatorWindowWithObservable(final Observable<U> other) {
         this.other = other;
@@ -132,11 +130,11 @@ void drain(List<Object> queue) {
                 if (o == NEXT_SUBJECT) {
                     replaceSubject();
                 } else
-                if (NL.isError(o)) {
-                    error(NL.getError(o));
+                if (NotificationLite.isError(o)) {
+                    error(NotificationLite.getError(o));
                     break;
                 } else
-                if (NL.isCompleted(o)) {
+                if (NotificationLite.isCompleted(o)) {
                     complete();
                     break;
                 } else {
@@ -170,7 +168,7 @@ void emitValue(T t) {
         public void onError(Throwable e) {
             synchronized (guard) {
                 if (emitting) {
-                    queue = Collections.singletonList(NL.error(e));
+                    queue = Collections.singletonList(NotificationLite.error(e));
                     return;
                 }
                 queue = null;
@@ -187,7 +185,7 @@ public void onCompleted() {
                     if (queue == null) {
                         queue = new ArrayList<Object>();
                     }
-                    queue.add(NL.completed());
+                    queue.add(NotificationLite.completed());
                     return;
                 }
                 localQueue = queue;
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
index 28d44c0643..ff28e04a50 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithObservableFactory.java
@@ -38,8 +38,6 @@ public final class OperatorWindowWithObservableFactory<T, U> implements Operator
 
     /** Indicate the current subject should complete and a new subject be emitted. */
     static final Object NEXT_SUBJECT = new Object();
-    /** For error and completion indication. */
-    static final NotificationLite<Object> NL = NotificationLite.instance();
 
     public OperatorWindowWithObservableFactory(Func0<? extends Observable<? extends U>> otherFactory) {
         this.otherFactory = otherFactory;
@@ -139,11 +137,11 @@ void drain(List<Object> queue) {
                 if (o == NEXT_SUBJECT) {
                     replaceSubject();
                 } else
-                if (NL.isError(o)) {
-                    error(NL.getError(o));
+                if (NotificationLite.isError(o)) {
+                    error(NotificationLite.getError(o));
                     break;
                 } else
-                if (NL.isCompleted(o)) {
+                if (NotificationLite.isCompleted(o)) {
                     complete();
                     break;
                 } else {
@@ -189,7 +187,7 @@ void emitValue(T t) {
         public void onError(Throwable e) {
             synchronized (guard) {
                 if (emitting) {
-                    queue = Collections.singletonList(NL.error(e));
+                    queue = Collections.singletonList(NotificationLite.error(e));
                     return;
                 }
                 queue = null;
@@ -206,7 +204,7 @@ public void onCompleted() {
                     if (queue == null) {
                         queue = new ArrayList<Object>();
                     }
-                    queue.add(NL.completed());
+                    queue.add(NotificationLite.completed());
                     return;
                 }
                 localQueue = queue;
diff --git a/src/main/java/rx/internal/operators/OperatorWindowWithTime.java b/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
index 17044bb5fe..717b7b7067 100644
--- a/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
+++ b/src/main/java/rx/internal/operators/OperatorWindowWithTime.java
@@ -48,8 +48,6 @@ public final class OperatorWindowWithTime<T> implements Operator<Observable<T>,
     final int size;
     /** Indicate the current subject should complete and a new subject be emitted. */
     static final Object NEXT_SUBJECT = new Object();
-    /** For error and completion indication. */
-    static final NotificationLite<Object> NL = NotificationLite.instance();
 
 
     public OperatorWindowWithTime(long timespan, long timeshift, TimeUnit unit, int size, Scheduler scheduler) {
@@ -187,11 +185,11 @@ boolean drain(List<Object> queue) {
                         return false;
                     }
                 } else
-                if (NL.isError(o)) {
-                    error(NL.getError(o));
+                if (NotificationLite.isError(o)) {
+                    error(NotificationLite.getError(o));
                     break;
                 } else
-                if (NL.isCompleted(o)) {
+                if (NotificationLite.isCompleted(o)) {
                     complete();
                     break;
                 } else {
@@ -244,7 +242,7 @@ public void onError(Throwable e) {
             synchronized (guard) {
                 if (emitting) {
                     // drop any queued action and terminate asap
-                    queue = Collections.<Object>singletonList(NL.error(e));
+                    queue = Collections.<Object>singletonList(NotificationLite.error(e));
                     return;
                 }
                 queue = null;
@@ -278,7 +276,7 @@ public void onCompleted() {
                     if (queue == null) {
                         queue = new ArrayList<Object>();
                     }
-                    queue.add(NL.completed());
+                    queue.add(NotificationLite.completed());
                     return;
                 }
                 localQueue = queue;
diff --git a/src/main/java/rx/internal/util/RxRingBuffer.java b/src/main/java/rx/internal/util/RxRingBuffer.java
index 314b135d1a..dfbb6cbd6f 100644
--- a/src/main/java/rx/internal/util/RxRingBuffer.java
+++ b/src/main/java/rx/internal/util/RxRingBuffer.java
@@ -125,8 +125,6 @@ public class RxRingBuffer implements Subscription {
      * } </pre>
      */
 
-    private static final NotificationLite<Object> ON = NotificationLite.instance();
-
     private Queue<Object> queue;
 
     private final int size;
@@ -342,7 +340,7 @@ public void onNext(Object o) throws MissingBackpressureException {
         synchronized (this) {
             Queue<Object> q = queue;
             if (q != null) {
-                mbe = !q.offer(ON.next(o));
+                mbe = !q.offer(NotificationLite.next(o));
             } else {
                 iae = true;
             }
@@ -359,14 +357,14 @@ public void onNext(Object o) throws MissingBackpressureException {
     public void onCompleted() {
         // we ignore terminal events if we already have one
         if (terminalState == null) {
-            terminalState = ON.completed();
+            terminalState = NotificationLite.completed();
         }
     }
 
     public void onError(Throwable t) {
         // we ignore terminal events if we already have one
         if (terminalState == null) {
-            terminalState = ON.error(t);
+            terminalState = NotificationLite.error(t);
         }
     }
 
@@ -429,24 +427,24 @@ public Object peek() {
     }
 
     public boolean isCompleted(Object o) {
-        return ON.isCompleted(o);
+        return NotificationLite.isCompleted(o);
     }
 
     public boolean isError(Object o) {
-        return ON.isError(o);
+        return NotificationLite.isError(o);
     }
 
     public Object getValue(Object o) {
-        return ON.getValue(o);
+        return NotificationLite.getValue(o);
     }
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public boolean accept(Object o, Observer child) {
-        return ON.accept(child, o);
+        return NotificationLite.accept(child, o);
     }
 
     public Throwable asError(Object o) {
-        return ON.getError(o);
+        return NotificationLite.getError(o);
     }
 
     @Override
diff --git a/src/main/java/rx/observables/BlockingObservable.java b/src/main/java/rx/observables/BlockingObservable.java
index 5a4c5944ef..59cb245415 100644
--- a/src/main/java/rx/observables/BlockingObservable.java
+++ b/src/main/java/rx/observables/BlockingObservable.java
@@ -507,22 +507,21 @@ public void onCompleted() {
      */
     @Beta
     public void subscribe(Observer<? super T> observer) {
-        final NotificationLite<T> nl = NotificationLite.instance();
         final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();
 
         @SuppressWarnings("unchecked")
         Subscription s = ((Observable<T>)o).subscribe(new Subscriber<T>() {
             @Override
             public void onNext(T t) {
-                queue.offer(nl.next(t));
+                queue.offer(NotificationLite.next(t));
             }
             @Override
             public void onError(Throwable e) {
-                queue.offer(nl.error(e));
+                queue.offer(NotificationLite.error(e));
             }
             @Override
             public void onCompleted() {
-                queue.offer(nl.completed());
+                queue.offer(NotificationLite.completed());
             }
         });
 
@@ -532,7 +531,7 @@ public void onCompleted() {
                 if (o == null) {
                     o = queue.take();
                 }
-                if (nl.accept(observer, o)) {
+                if (NotificationLite.accept(observer, o)) {
                     return;
                 }
             }
@@ -554,22 +553,21 @@ public void onCompleted() {
     @SuppressWarnings("unchecked")
     @Beta
     public void subscribe(Subscriber<? super T> subscriber) {
-        final NotificationLite<T> nl = NotificationLite.instance();
         final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();
         final Producer[] theProducer = { null };
 
         Subscriber<T> s = new Subscriber<T>() {
             @Override
             public void onNext(T t) {
-                queue.offer(nl.next(t));
+                queue.offer(NotificationLite.next(t));
             }
             @Override
             public void onError(Throwable e) {
-                queue.offer(nl.error(e));
+                queue.offer(NotificationLite.error(e));
             }
             @Override
             public void onCompleted() {
-                queue.offer(nl.completed());
+                queue.offer(NotificationLite.completed());
             }
 
             @Override
@@ -612,7 +610,7 @@ public void call() {
                 if (o == SET_PRODUCER) {
                     subscriber.setProducer(theProducer[0]);
                 } else
-                if (nl.accept(subscriber, o)) {
+                if (NotificationLite.accept(subscriber, o)) {
                     return;
                 }
             }
diff --git a/src/main/java/rx/observers/SerializedObserver.java b/src/main/java/rx/observers/SerializedObserver.java
index bf3c44a623..eb3afcf109 100644
--- a/src/main/java/rx/observers/SerializedObserver.java
+++ b/src/main/java/rx/observers/SerializedObserver.java
@@ -41,7 +41,6 @@ public class SerializedObserver<T> implements Observer<T> {
     private volatile boolean terminated;
     /** If not null, it indicates more work. */
     private FastList queue;
-    private final NotificationLite<T> nl = NotificationLite.instance();
 
     static final class FastList {
         Object[] array;
@@ -83,7 +82,7 @@ public void onNext(T t) {
                     list = new FastList();
                     queue = list;
                 }
-                list.add(nl.next(t));
+                list.add(NotificationLite.next(t));
                 return;
             }
             emitting = true;
@@ -110,7 +109,7 @@ public void onNext(T t) {
                     break;
                 }
                 try {
-                    if (nl.accept(actual, o)) {
+                    if (NotificationLite.accept(actual, o)) {
                         terminated = true;
                         return;
                     }
@@ -145,7 +144,7 @@ public void onError(final Throwable e) {
                     list = new FastList();
                     queue = list;
                 }
-                list.add(nl.error(e));
+                list.add(NotificationLite.error(e));
                 return;
             }
             emitting = true;
@@ -169,7 +168,7 @@ public void onCompleted() {
                     list = new FastList();
                     queue = list;
                 }
-                list.add(nl.completed());
+                list.add(NotificationLite.completed());
                 return;
             }
             emitting = true;
diff --git a/src/main/java/rx/subjects/AsyncSubject.java b/src/main/java/rx/subjects/AsyncSubject.java
index 4a1038b5ef..f7bd7a21be 100644
--- a/src/main/java/rx/subjects/AsyncSubject.java
+++ b/src/main/java/rx/subjects/AsyncSubject.java
@@ -59,7 +59,6 @@
 public final class AsyncSubject<T> extends Subject<T, T> {
     final SubjectSubscriptionManager<T> state;
     volatile Object lastValue;
-    private final NotificationLite<T> nl = NotificationLite.instance();
 
     /**
      * Creates and returns a new {@code AsyncSubject}.
@@ -72,14 +71,13 @@ public static <T> AsyncSubject<T> create() {
             @Override
             public void call(SubjectObserver<T> o) {
                 Object v = state.getLatest();
-                NotificationLite<T> nl = state.nl;
-                if (v == null || nl.isCompleted(v)) {
+                if (v == null || NotificationLite.isCompleted(v)) {
                     o.onCompleted();
                 } else
-                if (nl.isError(v)) {
-                    o.onError(nl.getError(v));
+                if (NotificationLite.isError(v)) {
+                    o.onError(NotificationLite.getError(v));
                 } else {
-                    o.actual.setProducer(new SingleProducer<T>(o.actual, nl.getValue(v)));
+                    o.actual.setProducer(new SingleProducer<T>(o.actual, NotificationLite.<T>getValue(v)));
                 }
             }
         };
@@ -96,13 +94,13 @@ public void onCompleted() {
         if (state.active) {
             Object last = lastValue;
             if (last == null) {
-                last = nl.completed();
+                last = NotificationLite.completed();
             }
             for (SubjectObserver<T> bo : state.terminate(last)) {
-                if (last == nl.completed()) {
+                if (last == NotificationLite.completed()) {
                     bo.onCompleted();
                 } else {
-                    bo.actual.setProducer(new SingleProducer<T>(bo.actual, nl.getValue(last)));
+                    bo.actual.setProducer(new SingleProducer<T>(bo.actual, NotificationLite.<T>getValue(last)));
                 }
             }
         }
@@ -111,7 +109,7 @@ public void onCompleted() {
     @Override
     public void onError(final Throwable e) {
         if (state.active) {
-            Object n = nl.error(e);
+            Object n = NotificationLite.error(e);
             List<Throwable> errors = null;
             for (SubjectObserver<T> bo : state.terminate(n)) {
                 try {
@@ -130,7 +128,7 @@ public void onError(final Throwable e) {
 
     @Override
     public void onNext(T v) {
-        lastValue = nl.next(v);
+        lastValue = NotificationLite.next(v);
     }
 
     @Override
@@ -148,7 +146,7 @@ public boolean hasObservers() {
     public boolean hasValue() {
         Object v = lastValue;
         Object o = state.getLatest();
-        return !nl.isError(o) && nl.isNext(v);
+        return !NotificationLite.isError(o) && NotificationLite.isNext(v);
     }
     /**
      * Check if the Subject has terminated with an exception.
@@ -157,7 +155,7 @@ public boolean hasValue() {
      */
     public boolean hasThrowable() {
         Object o = state.getLatest();
-        return nl.isError(o);
+        return NotificationLite.isError(o);
     }
     /**
      * Check if the Subject has terminated normally.
@@ -166,7 +164,7 @@ public boolean hasThrowable() {
      */
     public boolean hasCompleted() {
         Object o = state.getLatest();
-        return o != null && !nl.isError(o);
+        return o != null && !NotificationLite.isError(o);
     }
     /**
      * Returns the current value of the Subject if there is such a value and
@@ -181,8 +179,8 @@ public boolean hasCompleted() {
     public T getValue() {
         Object v = lastValue;
         Object o = state.getLatest();
-        if (!nl.isError(o) && nl.isNext(v)) {
-            return nl.getValue(v);
+        if (!NotificationLite.isError(o) && NotificationLite.isNext(v)) {
+            return NotificationLite.getValue(v);
         }
         return null;
     }
@@ -194,8 +192,8 @@ public T getValue() {
      */
     public Throwable getThrowable() {
         Object o = state.getLatest();
-        if (nl.isError(o)) {
-            return nl.getError(o);
+        if (NotificationLite.isError(o)) {
+            return NotificationLite.getError(o);
         }
         return null;
     }
diff --git a/src/main/java/rx/subjects/BehaviorSubject.java b/src/main/java/rx/subjects/BehaviorSubject.java
index c4d73751df..551f7f6c23 100644
--- a/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/src/main/java/rx/subjects/BehaviorSubject.java
@@ -72,7 +72,6 @@ public final class BehaviorSubject<T> extends Subject<T, T> {
     /** An empty array to trigger getValues() to return a new array. */
     private static final Object[] EMPTY_ARRAY = new Object[0];
     private final SubjectSubscriptionManager<T> state;
-    private final NotificationLite<T> nl = NotificationLite.instance();
 
     /**
      * Creates a {@link BehaviorSubject} without a default item.
@@ -101,13 +100,13 @@ public static <T> BehaviorSubject<T> create(T defaultValue) {
     private static <T> BehaviorSubject<T> create(T defaultValue, boolean hasDefault) {
         final SubjectSubscriptionManager<T> state = new SubjectSubscriptionManager<T>();
         if (hasDefault) {
-            state.setLatest(NotificationLite.instance().next(defaultValue));
+            state.setLatest(NotificationLite.next(defaultValue));
         }
         state.onAdded = new Action1<SubjectObserver<T>>() {
 
             @Override
             public void call(SubjectObserver<T> o) {
-                o.emitFirst(state.getLatest(), state.nl);
+                o.emitFirst(state.getLatest());
             }
 
         };
@@ -124,9 +123,9 @@ protected BehaviorSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager
     public void onCompleted() {
         Object last = state.getLatest();
         if (last == null || state.active) {
-            Object n = nl.completed();
+            Object n = NotificationLite.completed();
             for (SubjectObserver<T> bo : state.terminate(n)) {
-                bo.emitNext(n, state.nl);
+                bo.emitNext(n);
             }
         }
     }
@@ -135,11 +134,11 @@ public void onCompleted() {
     public void onError(Throwable e) {
         Object last = state.getLatest();
         if (last == null || state.active) {
-            Object n = nl.error(e);
+            Object n = NotificationLite.error(e);
             List<Throwable> errors = null;
             for (SubjectObserver<T> bo : state.terminate(n)) {
                 try {
-                    bo.emitNext(n, state.nl);
+                    bo.emitNext(n);
                 } catch (Throwable e2) {
                     if (errors == null) {
                         errors = new ArrayList<Throwable>();
@@ -156,9 +155,9 @@ public void onError(Throwable e) {
     public void onNext(T v) {
         Object last = state.getLatest();
         if (last == null || state.active) {
-            Object n = nl.next(v);
+            Object n = NotificationLite.next(v);
             for (SubjectObserver<T> bo : state.next(n)) {
-                bo.emitNext(n, state.nl);
+                bo.emitNext(n);
             }
         }
     }
@@ -181,7 +180,7 @@ public boolean hasObservers() {
      */
     public boolean hasValue() {
         Object o = state.getLatest();
-        return nl.isNext(o);
+        return NotificationLite.isNext(o);
     }
     /**
      * Check if the Subject has terminated with an exception.
@@ -190,7 +189,7 @@ public boolean hasValue() {
      */
     public boolean hasThrowable() {
         Object o = state.getLatest();
-        return nl.isError(o);
+        return NotificationLite.isError(o);
     }
     /**
      * Check if the Subject has terminated normally.
@@ -199,7 +198,7 @@ public boolean hasThrowable() {
      */
     public boolean hasCompleted() {
         Object o = state.getLatest();
-        return nl.isCompleted(o);
+        return NotificationLite.isCompleted(o);
     }
     /**
      * Returns the current value of the Subject if there is such a value and
@@ -213,8 +212,8 @@ public boolean hasCompleted() {
      */
     public T getValue() {
         Object o = state.getLatest();
-        if (nl.isNext(o)) {
-            return nl.getValue(o);
+        if (NotificationLite.isNext(o)) {
+            return NotificationLite.getValue(o);
         }
         return null;
     }
@@ -226,8 +225,8 @@ public T getValue() {
      */
     public Throwable getThrowable() {
         Object o = state.getLatest();
-        if (nl.isError(o)) {
-            return nl.getError(o);
+        if (NotificationLite.isError(o)) {
+            return NotificationLite.getError(o);
         }
         return null;
     }
@@ -241,11 +240,11 @@ public Throwable getThrowable() {
     @SuppressWarnings("unchecked")
     public T[] getValues(T[] a) {
         Object o = state.getLatest();
-        if (nl.isNext(o)) {
+        if (NotificationLite.isNext(o)) {
             if (a.length == 0) {
                 a = (T[])Array.newInstance(a.getClass().getComponentType(), 1);
             }
-            a[0] = nl.getValue(o);
+            a[0] = NotificationLite.getValue(o);
             if (a.length > 1) {
                 a[1] = null;
             }
diff --git a/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index e4ca112c67..3e486d2ce8 100644
--- a/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -46,8 +46,6 @@
     Action1<SubjectObserver<T>> onAdded = Actions.empty();
     /** Action called when the subscriber wants to subscribe to a terminal state. */
     Action1<SubjectObserver<T>> onTerminated = Actions.empty();
-    /** The notification lite. */
-    public final NotificationLite<T> nl = NotificationLite.instance();
 
     public SubjectSubscriptionManager() {
         super(State.EMPTY);
@@ -238,7 +236,7 @@ public void onCompleted() {
          * @param n the NotificationLite value
          * @param nl the type-appropriate notification lite object
          */
-        void emitNext(Object n, final NotificationLite<T> nl) {
+        void emitNext(Object n) {
             if (!fastPath) {
                 synchronized (this) {
                     first = false;
@@ -252,15 +250,14 @@ void emitNext(Object n, final NotificationLite<T> nl) {
                 }
                 fastPath = true;
             }
-            nl.accept(actual, n);
+            NotificationLite.accept(actual, n);
         }
         /**
          * Tries to emit a NotificationLite value as the first
          * value and drains the queue as long as possible.
-         * @param n the NotificationLite value
          * @param nl the type-appropriate notification lite object
          */
-        void emitFirst(Object n, final NotificationLite<T> nl) {
+        void emitFirst(Object n) {
             synchronized (this) {
                 if (!first || emitting) {
                     return;
@@ -269,7 +266,7 @@ void emitFirst(Object n, final NotificationLite<T> nl) {
                 emitting = n != null;
             }
             if (n != null) {
-                emitLoop(null, n, nl);
+                emitLoop(null, n);
             }
         }
         /**
@@ -278,19 +275,19 @@ void emitFirst(Object n, final NotificationLite<T> nl) {
          * @param current the current content to emit
          * @param nl the type-appropriate notification lite object
          */
-        void emitLoop(List<Object> localQueue, Object current, final NotificationLite<T> nl) {
+        void emitLoop(List<Object> localQueue, Object current) {
             boolean once = true;
             boolean skipFinal = false;
             try {
                 do {
                     if (localQueue != null) {
                         for (Object n : localQueue) {
-                            accept(n, nl);
+                            accept(n);
                         }
                     }
                     if (once) {
                         once = false;
-                        accept(current, nl);
+                        accept(current);
                     }
                     synchronized (this) {
                         localQueue = queue;
@@ -315,9 +312,9 @@ void emitLoop(List<Object> localQueue, Object current, final NotificationLite<T>
          * @param n the value to dispatch
          * @param nl the type-appropriate notification lite object
          */
-        void accept(Object n, final NotificationLite<T> nl) {
+        void accept(Object n) {
             if (n != null) {
-                nl.accept(actual, n);
+                NotificationLite.accept(actual, n);
             }
         }
 
diff --git a/src/main/java/rx/subjects/TestSubject.java b/src/main/java/rx/subjects/TestSubject.java
index 6c5cfd2e5a..be142ea0f3 100644
--- a/src/main/java/rx/subjects/TestSubject.java
+++ b/src/main/java/rx/subjects/TestSubject.java
@@ -52,7 +52,7 @@ public static <T> TestSubject<T> create(TestScheduler scheduler) {
 
             @Override
             public void call(SubjectObserver<T> o) {
-                o.emitFirst(state.getLatest(), state.nl);
+                o.emitFirst(state.getLatest());
             }
 
         };
@@ -77,7 +77,7 @@ public void onCompleted() {
 
     void internalOnCompleted() {
         if (state.active) {
-            for (SubjectObserver<T> bo : state.terminate(NotificationLite.instance().completed())) {
+            for (SubjectObserver<T> bo : state.terminate(NotificationLite.completed())) {
                 bo.onCompleted();
             }
         }
@@ -110,7 +110,7 @@ public void onError(final Throwable e) {
 
     void internalOnError(final Throwable e) {
         if (state.active) {
-            for (SubjectObserver<T> bo : state.terminate(NotificationLite.instance().error(e))) {
+            for (SubjectObserver<T> bo : state.terminate(NotificationLite.error(e))) {
                 bo.onError(e);
             }
         }
diff --git a/src/main/java/rx/subjects/UnicastSubject.java b/src/main/java/rx/subjects/UnicastSubject.java
index 70f4a96a16..c1c69f9e36 100644
--- a/src/main/java/rx/subjects/UnicastSubject.java
+++ b/src/main/java/rx/subjects/UnicastSubject.java
@@ -119,8 +119,6 @@ static final class State<T> extends AtomicLong implements Producer, Observer<T>,
         final AtomicReference<Subscriber<? super T>> subscriber;
         /** The queue holding values until the subscriber arrives and catches up. */
         final Queue<Object> queue;
-        /** JCTools queues don't accept nulls. */
-        final NotificationLite<T> nl;
         /** Atomically set to true on terminal condition. */
         final AtomicReference<Action0> terminateOnce;
         /** In case the source emitted an error. */
@@ -141,7 +139,6 @@ static final class State<T> extends AtomicLong implements Producer, Observer<T>,
          * the single subscriber unsubscribes.
          */
         public State(int capacityHint, Action0 onTerminated) {
-            this.nl = NotificationLite.instance();
             this.subscriber = new AtomicReference<Subscriber<? super T>>();
             this.terminateOnce = onTerminated != null ? new AtomicReference<Action0>(onTerminated) : null;
 
@@ -171,7 +168,7 @@ public void onNext(T t) {
                      */
                     synchronized (this) {
                         if (!caughtUp) {
-                            queue.offer(nl.next(t));
+                            queue.offer(NotificationLite.next(t));
                             stillReplay = true;
                         }
                     }
@@ -293,7 +290,7 @@ void replay() {
                         if (empty) {
                             break;
                         }
-                        T value = nl.getValue(v);
+                        T value = NotificationLite.getValue(v);
                         try {
                             s.onNext(value);
                         } catch (Throwable ex) {
diff --git a/src/test/java/rx/internal/operators/NotificationLiteTest.java b/src/test/java/rx/internal/operators/NotificationLiteTest.java
index ed6e3cb768..74e6201baa 100644
--- a/src/test/java/rx/internal/operators/NotificationLiteTest.java
+++ b/src/test/java/rx/internal/operators/NotificationLiteTest.java
@@ -26,30 +26,28 @@ public class NotificationLiteTest {
 
     @Test
     public void testComplete() {
-        NotificationLite<Object> on = NotificationLite.instance();
-        Object n = on.next("Hello");
-        Object c = on.completed();
+        Object n = NotificationLite.next("Hello");
+        Object c = NotificationLite.completed();
 
-        assertTrue(on.isCompleted(c));
-        assertFalse(on.isCompleted(n));
+        assertTrue(NotificationLite.isCompleted(c));
+        assertFalse(NotificationLite.isCompleted(n));
 
-        assertEquals("Hello", on.getValue(n));
+        assertEquals("Hello", NotificationLite.getValue(n));
     }
 
     @Test
     public void testValueKind() {
-        NotificationLite<Object> on = NotificationLite.instance();
-
-        assertTrue(on.isNull(on.next(null)));
-        assertFalse(on.isNull(on.next(1)));
-        assertFalse(on.isNull(on.error(new TestException())));
-        assertFalse(on.isNull(on.completed()));
-        assertFalse(on.isNull(null));
-
-        assertTrue(on.isNext(on.next(null)));
-        assertTrue(on.isNext(on.next(1)));
-        assertFalse(on.isNext(on.completed()));
-        assertFalse(on.isNext(null));
-        assertFalse(on.isNext(on.error(new TestException())));
+
+        assertTrue(NotificationLite.isNull(NotificationLite.next(null)));
+        assertFalse(NotificationLite.isNull(NotificationLite.next(1)));
+        assertFalse(NotificationLite.isNull(NotificationLite.error(new TestException())));
+        assertFalse(NotificationLite.isNull(NotificationLite.completed()));
+        assertFalse(NotificationLite.isNull(null));
+
+        assertTrue(NotificationLite.isNext(NotificationLite.next(null)));
+        assertTrue(NotificationLite.isNext(NotificationLite.next(1)));
+        assertFalse(NotificationLite.isNext(NotificationLite.completed()));
+        assertFalse(NotificationLite.isNext(null));
+        assertFalse(NotificationLite.isNext(NotificationLite.error(new TestException())));
     }
 }

From 09b13891bbc3c9fcafab79ada2f55ee0e2d32811 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 30 Sep 2016 20:39:25 +0200
Subject: [PATCH 176/263] 1.x: SafeSubscriber not to call RxJavaHooks before
 delivering the (#4641)

original error.
---
 .../java/rx/observers/SafeSubscriber.java     |  5 +++--
 src/test/java/rx/plugins/RxJavaHooksTest.java | 21 +++++++++++++++++++
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/observers/SafeSubscriber.java b/src/main/java/rx/observers/SafeSubscriber.java
index 75dab2f020..717946c032 100644
--- a/src/main/java/rx/observers/SafeSubscriber.java
+++ b/src/main/java/rx/observers/SafeSubscriber.java
@@ -19,7 +19,7 @@
 
 import rx.Subscriber;
 import rx.exceptions.*;
-import rx.plugins.RxJavaHooks;
+import rx.plugins.*;
 
 /**
  * {@code SafeSubscriber} is a wrapper around {@code Subscriber} that ensures that the {@code Subscriber}
@@ -146,8 +146,9 @@ public void onNext(T args) {
      *
      * @see <a href="https://github.com/ReactiveX/RxJava/issues/630">the report of this bug</a>
      */
+    @SuppressWarnings("deprecation")
     protected void _onError(Throwable e) { // NOPMD
-        RxJavaHooks.onError(e);
+        RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
         try {
             actual.onError(e);
         } catch (OnErrorNotImplementedException e2) { // NOPMD
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index b9fc370d69..a3b78678ef 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -1084,4 +1084,25 @@ public Completable.Operator onLift(Completable.Operator lift) {
         }
     }
 
+    @Test
+    public void noCallToHooksOnPlainError() {
+
+        final boolean[] called = { false };
+        
+        RxJavaHooks.setOnError(new Action1<Throwable>() {
+            @Override
+            public void call(Throwable t) {
+                called[0] = true;
+            }
+        });
+        
+        try {
+            Observable.error(new TestException())
+            .subscribe(new TestSubscriber<Object>());
+            
+            assertFalse(called[0]);
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
 }

From 843a57e71d8e2e0b8e0e6329629d3253791b8483 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sun, 2 Oct 2016 12:10:15 +0200
Subject: [PATCH 177/263] 1.x: rework Single internals to reduce overhead and
 stack depth (#4648)

* 1.x: rework Single internals to reduce overhead and stack depth

* Remove auto-gen TODO, mark Single(Observable.OnSubscribe) deprecated
---
 src/main/java/rx/Completable.java             |   1 +
 src/main/java/rx/Observable.java              |   6 +-
 src/main/java/rx/Single.java                  | 411 ++++--------------
 .../operators/CompletableFromEmitter.java     |   1 +
 .../internal/operators/NotificationLite.java  |   3 +
 .../rx/internal/operators/SingleDelay.java    | 109 +++++
 .../operators/SingleDoOnSubscribe.java        |  52 +++
 .../operators/SingleDoOnUnsubscribe.java      |  44 ++
 .../operators/SingleFromCallable.java         |  50 +++
 .../internal/operators/SingleFromFuture.java  |  66 +++
 .../operators/SingleFromObservable.java       |  94 ++++
 .../SingleLiftObservableOperator.java         |  84 ++++
 .../internal/operators/SingleObserveOn.java   |  95 ++++
 .../operators/SingleOnErrorReturn.java        |  79 ++++
 .../operators/SingleTakeUntilCompletable.java |  92 ++++
 .../operators/SingleTakeUntilObservable.java  | 103 +++++
 .../operators/SingleTakeUntilSingle.java      |  98 +++++
 .../rx/internal/operators/SingleTimeout.java  | 137 ++++++
 .../operators/SingleToObservable.java         |  41 ++
 .../util/ScalarSynchronousSingle.java         |  19 +-
 src/main/java/rx/plugins/RxJavaHooks.java     |  24 +-
 src/test/java/rx/ObservableDoOnTest.java      |   2 +-
 src/test/java/rx/SingleTest.java              |  10 +-
 .../operators/CompletableFromEmitterTest.java |   1 +
 .../operators/OperatorDoOnRequestTest.java    |   2 +-
 .../operators/SingleOnSubscribeUsingTest.java |   8 +-
 src/test/java/rx/plugins/RxJavaHooksTest.java |  13 +-
 27 files changed, 1271 insertions(+), 374 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/SingleDelay.java
 create mode 100644 src/main/java/rx/internal/operators/SingleDoOnSubscribe.java
 create mode 100644 src/main/java/rx/internal/operators/SingleDoOnUnsubscribe.java
 create mode 100644 src/main/java/rx/internal/operators/SingleFromCallable.java
 create mode 100644 src/main/java/rx/internal/operators/SingleFromFuture.java
 create mode 100644 src/main/java/rx/internal/operators/SingleFromObservable.java
 create mode 100644 src/main/java/rx/internal/operators/SingleLiftObservableOperator.java
 create mode 100644 src/main/java/rx/internal/operators/SingleObserveOn.java
 create mode 100644 src/main/java/rx/internal/operators/SingleOnErrorReturn.java
 create mode 100644 src/main/java/rx/internal/operators/SingleTakeUntilCompletable.java
 create mode 100644 src/main/java/rx/internal/operators/SingleTakeUntilObservable.java
 create mode 100644 src/main/java/rx/internal/operators/SingleTakeUntilSingle.java
 create mode 100644 src/main/java/rx/internal/operators/SingleTimeout.java
 create mode 100644 src/main/java/rx/internal/operators/SingleToObservable.java

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index e604fdaf71..e9ae55239a 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -540,6 +540,7 @@ public void call(rx.CompletableSubscriber s) {
      * @return the new Completable instance
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
+    @SuppressWarnings("deprecation")
     @Experimental
     public static Completable fromEmitter(Action1<CompletableEmitter> producer) {
         return create(new CompletableFromEmitter(producer));
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 8936d489ba..b3872d847d 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -2016,7 +2016,7 @@ public static <T> Observable<T> from(T[] array) {
      * @see AsyncEmitter.BackpressureMode
      * @see AsyncEmitter.Cancellable
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
-     * @deprecated since 1.2.1 because Async prefix of AsyncEmitter class is potentially misleading. Use 
+     * @deprecated since 1.2.1 because Async prefix of AsyncEmitter class is potentially misleading. Use
      *            {@link #fromEmitter(Action1, Emitter.BackpressureMode)} instead.
      */
     @Experimental
@@ -2024,7 +2024,7 @@ public static <T> Observable<T> from(T[] array) {
     public static <T> Observable<T> fromEmitter(Action1<AsyncEmitter<T>> emitter, AsyncEmitter.BackpressureMode backpressure) {
         return create(new OnSubscribeFromAsyncEmitter<T>(emitter, backpressure));
     }
-    
+
     /**
      * Provides an API (via a cold Observable) that bridges the reactive world with the callback-style,
      * generally non-backpressured world.
@@ -2063,7 +2063,7 @@ public static <T> Observable<T> fromEmitter(Action1<AsyncEmitter<T>> emitter, As
      * @return the new Observable instance
      * @see Emitter
      * @see Emitter.BackpressureMode
-     * @see Emitter.Cancellable
+     * @see rx.functions.Cancellable
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
     @Experimental
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 5d83ec45d4..5095143c2e 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -20,7 +20,6 @@
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.internal.operators.*;
-import rx.internal.producers.SingleDelayedProducer;
 import rx.internal.util.*;
 import rx.observers.*;
 import rx.plugins.RxJavaHooks;
@@ -51,7 +50,7 @@
  */
 public class Single<T> {
 
-    final Observable.OnSubscribe<T> onSubscribe;
+    final OnSubscribe<T> onSubscribe;
 
     /**
      * Creates a Single with a Function to execute when it is subscribed to (executed).
@@ -60,40 +59,28 @@ public class Single<T> {
      * unless you specifically have a need for inheritance.
      *
      * @param f
-     *            {@code OnExecute} to be executed when {@code execute(SingleSubscriber)} or
+     *            {@code f} to be executed when {@code execute(SingleSubscriber)} or
      *            {@code subscribe(Subscriber)} is called
      */
     protected Single(OnSubscribe<T> f) {
-        final OnSubscribe<T> g = RxJavaHooks.onCreate(f);
-        // bridge between OnSubscribe (which all Operators and Observables use) and OnExecute (for Single)
-        this.onSubscribe = new Observable.OnSubscribe<T>() {
-
-            @Override
-            public void call(final Subscriber<? super T> child) {
-                final SingleDelayedProducer<T> producer = new SingleDelayedProducer<T>(child);
-                child.setProducer(producer);
-                SingleSubscriber<T> ss = new SingleSubscriber<T>() {
-
-                    @Override
-                    public void onSuccess(T value) {
-                        producer.setValue(value);
-                    }
-
-                    @Override
-                    public void onError(Throwable error) {
-                        child.onError(error);
-                    }
-
-                };
-                child.add(ss);
-                g.call(ss);
-            }
-
-        };
+        this.onSubscribe = RxJavaHooks.onCreate(f);
     }
 
-    private Single(final Observable.OnSubscribe<T> f) {
-        this.onSubscribe = RxJavaHooks.onCreate(f);
+    /**
+     * Creates a Single with a Function to execute when it is subscribed to (executed).
+     * <p>
+     * <em>Note:</em> Use {@link #create(OnSubscribe)} to create a Single, instead of this constructor,
+     * unless you specifically have a need for inheritance.
+     *
+     * @param f
+     *            {@code f} to be executed when {@code execute(SingleSubscriber)} or
+     *            {@code subscribe(Subscriber)} is called
+     * @deprecated 1.2.1: Not recommended, use {@link #Single(OnSubscribe)} to avoid wrapping and
+     * conversion between the Observable and Single protocols.
+     */
+    @Deprecated
+    protected Single(final Observable.OnSubscribe<T> f) {
+        onSubscribe = RxJavaHooks.onCreate(new SingleFromObservable<T>(f));
     }
 
     /**
@@ -159,28 +146,7 @@ public interface OnSubscribe<T> extends Action1<SingleSubscriber<? super T>> {
      */
     @Beta
     public final <R> Single<R> lift(final Operator<? extends R, ? super T> lift) {
-        return new Single<R>(new Observable.OnSubscribe<R>() {
-            @Override
-            public void call(Subscriber<? super R> o) {
-                try {
-                    final Subscriber<? super T> st = RxJavaHooks.onSingleLift(lift).call(o);
-                    try {
-                        // new Subscriber created and being subscribed with so 'onStart' it
-                        st.onStart();
-                        onSubscribe.call(st);
-                    } catch (Throwable e) {
-                        // localized capture of errors rather than it skipping all operators
-                        // and ending up in the try/catch of the subscribe method which then
-                        // prevents onErrorResumeNext and other similar approaches to error handling
-                        Exceptions.throwOrReport(e, st);
-                    }
-                } catch (Throwable e) {
-                    // if the lift function failed all we can do is pass the error to the final Subscriber
-                    // as we don't have the operator available to us
-                    Exceptions.throwOrReport(e, o);
-                }
-            }
-        });
+        return create(new SingleLiftObservableOperator<T, R>(this.onSubscribe, lift));
     }
 
     /**
@@ -234,7 +200,7 @@ public interface Transformer<T, R> extends Func1<Single<T>, Single<R>> {
      */
     private static <T> Observable<T> asObservable(Single<T> t) {
         // is this sufficient, or do I need to keep the outer Single and subscribe to it?
-        return Observable.create(t.onSubscribe);
+        return Observable.create(new SingleToObservable<T>(t.onSubscribe));
     }
 
     /* *********************************************************************************************************
@@ -518,9 +484,8 @@ public void call(SingleSubscriber<? super T> te) {
      * @return a {@code Single} that emits the item from the source {@link Future}
      * @see <a href="http://reactivex.io/documentation/operators/from.html">ReactiveX operators documentation: From</a>
      */
-    @SuppressWarnings("cast")
     public static <T> Single<T> from(Future<? extends T> future) {
-        return new Single<T>((Observable.OnSubscribe<T>)OnSubscribeToObservableFuture.toObservableFuture(future));
+        return create(new SingleFromFuture<T>(future, 0, null));
     }
 
     /**
@@ -550,9 +515,11 @@ public static <T> Single<T> from(Future<? extends T> future) {
      * @return a {@code Single} that emits the item from the source {@link Future}
      * @see <a href="http://reactivex.io/documentation/operators/from.html">ReactiveX operators documentation: From</a>
      */
-    @SuppressWarnings("cast")
     public static <T> Single<T> from(Future<? extends T> future, long timeout, TimeUnit unit) {
-        return new Single<T>((Observable.OnSubscribe<T>)OnSubscribeToObservableFuture.toObservableFuture(future, timeout, unit));
+        if (unit == null) {
+            throw new NullPointerException("unit is null");
+        }
+        return create(new SingleFromFuture<T>(future, timeout, unit));
     }
 
     /**
@@ -579,9 +546,8 @@ public static <T> Single<T> from(Future<? extends T> future, long timeout, TimeU
      * @return a {@code Single} that emits the item from the source {@link Future}
      * @see <a href="http://reactivex.io/documentation/operators/from.html">ReactiveX operators documentation: From</a>
      */
-    @SuppressWarnings("cast")
     public static <T> Single<T> from(Future<? extends T> future, Scheduler scheduler) {
-        return new Single<T>((Observable.OnSubscribe<T>)OnSubscribeToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler);
+        return from(future).subscribeOn(scheduler);
     }
 
     /**
@@ -602,22 +568,7 @@ public static <T> Single<T> from(Future<? extends T> future, Scheduler scheduler
      * @return a {@link Single} whose {@link Observer}s' subscriptions trigger an invocation of the given function.
      */
     public static <T> Single<T> fromCallable(final Callable<? extends T> func) {
-        return create(new OnSubscribe<T>() {
-            @Override
-            public void call(SingleSubscriber<? super T> singleSubscriber) {
-                T value;
-
-                try {
-                    value = func.call();
-                } catch (Throwable t) {
-                    Exceptions.throwIfFatal(t);
-                    singleSubscriber.onError(t);
-                    return;
-                }
-
-                singleSubscriber.onSuccess(value);
-            }
-        });
+        return create(new SingleFromCallable<T>(func));
     }
 
     /**
@@ -1467,9 +1418,10 @@ public final Single<T> observeOn(Scheduler scheduler) {
         if (this instanceof ScalarSynchronousSingle) {
             return ((ScalarSynchronousSingle<T>)this).scalarScheduleOn(scheduler);
         }
-        // Note that since Single emits onSuccess xor onError,
-        // there is no cut-ahead possible like with regular Observable sequences.
-        return lift(new OperatorObserveOn<T>(scheduler, false));
+        if (scheduler == null) {
+            throw new NullPointerException("scheduler is null");
+        }
+        return create(new SingleObserveOn<T>(onSubscribe, scheduler));
     }
 
     /**
@@ -1498,9 +1450,8 @@ public final Single<T> observeOn(Scheduler scheduler) {
      * @return the original Single with appropriately modified behavior
      * @see <a href="http://reactivex.io/documentation/operators/catch.html">ReactiveX operators documentation: Catch</a>
      */
-    @SuppressWarnings("cast")
     public final Single<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunction) {
-        return lift((Operator<T, T>)OperatorOnErrorResumeNextViaFunction.withSingle(resumeFunction));
+        return create(new SingleOnErrorReturn<T>(onSubscribe, resumeFunction));
     }
 
     /**
@@ -1584,12 +1535,7 @@ public final Single<T> onErrorResumeNext(final Func1<Throwable, ? extends Single
      * @see <a href="http://reactivex.io/documentation/operators/subscribe.html">ReactiveX operators documentation: Subscribe</a>
      */
     public final Subscription subscribe() {
-        return subscribe(new Subscriber<T>() {
-
-            @Override
-            public final void onCompleted() {
-                // do nothing
-            }
+        return subscribe(new SingleSubscriber<T>() {
 
             @Override
             public final void onError(Throwable e) {
@@ -1597,7 +1543,7 @@ public final void onError(Throwable e) {
             }
 
             @Override
-            public final void onNext(T args) {
+            public final void onSuccess(T args) {
                 // do nothing
             }
 
@@ -1625,12 +1571,7 @@ public final Subscription subscribe(final Action1<? super T> onSuccess) {
             throw new IllegalArgumentException("onSuccess can not be null");
         }
 
-        return subscribe(new Subscriber<T>() {
-
-            @Override
-            public final void onCompleted() {
-                // do nothing
-            }
+        return subscribe(new SingleSubscriber<T>() {
 
             @Override
             public final void onError(Throwable e) {
@@ -1638,7 +1579,7 @@ public final void onError(Throwable e) {
             }
 
             @Override
-            public final void onNext(T args) {
+            public final void onSuccess(T args) {
                 onSuccess.call(args);
             }
 
@@ -1672,12 +1613,7 @@ public final Subscription subscribe(final Action1<? super T> onSuccess, final Ac
             throw new IllegalArgumentException("onError can not be null");
         }
 
-        return subscribe(new Subscriber<T>() {
-
-            @Override
-            public final void onCompleted() {
-                // do nothing
-            }
+        return subscribe(new SingleSubscriber<T>() {
 
             @Override
             public final void onError(Throwable e) {
@@ -1685,7 +1621,7 @@ public final void onError(Throwable e) {
             }
 
             @Override
-            public final void onNext(T args) {
+            public final void onSuccess(T args) {
                 onSuccess.call(args);
             }
 
@@ -1708,10 +1644,16 @@ public final void onNext(T args) {
      * @return the subscription that allows unsubscribing
      */
     public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
+        return unsafeSubscribe(subscriber, true);
+    }
+
+    private Subscription unsafeSubscribe(Subscriber<? super T> subscriber, boolean start) {
         try {
-            // new Subscriber so onStart it
-            subscriber.onStart();
-            RxJavaHooks.onSingleStart(this, onSubscribe).call(subscriber);
+            if (start) {
+                // new Subscriber so onStart it
+                subscriber.onStart();
+            }
+            RxJavaHooks.onSingleStart(this, onSubscribe).call(SingleLiftObservableOperator.wrap(subscriber));
             return RxJavaHooks.onSingleReturn(subscriber);
         } catch (Throwable e) {
             // special handling for certain Throwable/Error/Exception types
@@ -1797,13 +1739,6 @@ public final Subscription subscribe(Subscriber<? super T> subscriber) {
         if (subscriber == null) {
             throw new IllegalArgumentException("observer can not be null");
         }
-        if (onSubscribe == null) {
-            throw new IllegalStateException("onSubscribe function can not be null.");
-            /*
-             * the subscribe function can also be overridden but generally that's not the appropriate approach
-             * so I won't mention that in the exception
-             */
-        }
 
         // new Subscriber so onStart it
         subscriber.onStart();
@@ -1815,32 +1750,9 @@ public final Subscription subscribe(Subscriber<? super T> subscriber) {
         // if not already wrapped
         if (!(subscriber instanceof SafeSubscriber)) {
             // assign to `observer` so we return the protected version
-            subscriber = new SafeSubscriber<T>(subscriber);
-        }
-
-        // The code below is exactly the same an unsafeSubscribe but not used because it would add a significant depth to already huge call stacks.
-        try {
-            // allow the hook to intercept and/or decorate
-            RxJavaHooks.onSingleStart(this, onSubscribe).call(subscriber);
-            return RxJavaHooks.onSingleReturn(subscriber);
-        } catch (Throwable e) {
-            // special handling for certain Throwable/Error/Exception types
-            Exceptions.throwIfFatal(e);
-            // if an unhandled error occurs executing the onSubscribe we will propagate it
-            try {
-                subscriber.onError(RxJavaHooks.onSingleError(e));
-            } catch (Throwable e2) {
-                Exceptions.throwIfFatal(e2);
-                // if this happens it means the onError itself failed (perhaps an invalid function implementation)
-                // so we are unable to propagate the error correctly and will just throw
-                RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
-                // TODO could the hook be the cause of the error in the on error handling.
-                RxJavaHooks.onSingleError(r);
-                // TODO why aren't we throwing the hook's return value.
-                throw r; // NOPMD
-            }
-            return Subscriptions.empty();
+            return unsafeSubscribe(new SafeSubscriber<T>(subscriber), false);
         }
+        return unsafeSubscribe(subscriber, true);
     }
 
     /**
@@ -1879,27 +1791,29 @@ public final Subscription subscribe(Subscriber<? super T> subscriber) {
      * @see <a href="http://reactivex.io/documentation/operators/subscribe.html">ReactiveX operators documentation: Subscribe</a>
      */
     public final Subscription subscribe(final SingleSubscriber<? super T> te) {
-        Subscriber<T> s = new Subscriber<T>() {
-
-            @Override
-            public void onCompleted() {
-                // deliberately ignored
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                te.onError(e);
-            }
-
-            @Override
-            public void onNext(T t) {
-                te.onSuccess(t);
+        if (te == null) {
+            throw new IllegalArgumentException("te is null");
+        }
+        try {
+            RxJavaHooks.onSingleStart(this, onSubscribe).call(te);
+            return RxJavaHooks.onSingleReturn(te);
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            // if an unhandled error occurs executing the onSubscribe we will propagate it
+            try {
+                te.onError(RxJavaHooks.onSingleError(ex));
+            } catch (Throwable e2) {
+                Exceptions.throwIfFatal(e2);
+                // if this happens it means the onError itself failed (perhaps an invalid function implementation)
+                // so we are unable to propagate the error correctly and will just throw
+                RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + ex.getMessage() + "] and then again while trying to pass to onError.", e2);
+                // TODO could the hook be the cause of the error in the on error handling.
+                RxJavaHooks.onSingleError(r);
+                // TODO why aren't we throwing the hook's return value.
+                throw r; // NOPMD
             }
-
-        };
-        te.add(s);
-        subscribe(s);
-        return s;
+            return Subscriptions.empty();
+        }
     }
 
     /**
@@ -1978,59 +1892,7 @@ public void onError(Throwable error) {
      * @see <a href="http://reactivex.io/documentation/operators/takeuntil.html">ReactiveX operators documentation: TakeUntil</a>
      */
     public final Single<T> takeUntil(final Completable other) {
-        return lift(new Operator<T, T>() {
-            @Override
-            public Subscriber<? super T> call(Subscriber<? super T> child) {
-                final Subscriber<T> serial = new SerializedSubscriber<T>(child, false);
-
-                final Subscriber<T> main = new Subscriber<T>(serial, false) {
-                    @Override
-                    public void onNext(T t) {
-                        serial.onNext(t);
-                    }
-                    @Override
-                    public void onError(Throwable e) {
-                        try {
-                            serial.onError(e);
-                        } finally {
-                            serial.unsubscribe();
-                        }
-                    }
-                    @Override
-                    public void onCompleted() {
-                        try {
-                            serial.onCompleted();
-                        } finally {
-                            serial.unsubscribe();
-                        }
-                    }
-                };
-
-                final CompletableSubscriber so = new CompletableSubscriber() {
-                    @Override
-                    public void onCompleted() {
-                        onError(new CancellationException("Stream was canceled before emitting a terminal event."));
-                    }
-
-                    @Override
-                    public void onError(Throwable e) {
-                        main.onError(e);
-                    }
-
-                    @Override
-                    public void onSubscribe(Subscription d) {
-                        serial.add(d);
-                    }
-                };
-
-                serial.add(main);
-                child.add(serial);
-
-                other.unsafeSubscribe(so);
-
-                return main;
-            }
-        });
+        return create(new SingleTakeUntilCompletable<T>(onSubscribe, other));
     }
 
     /**
@@ -2054,62 +1916,7 @@ public void onSubscribe(Subscription d) {
      * @see <a href="http://reactivex.io/documentation/operators/takeuntil.html">ReactiveX operators documentation: TakeUntil</a>
      */
     public final <E> Single<T> takeUntil(final Observable<? extends E> other) {
-        return lift(new Operator<T, T>() {
-            @Override
-            public Subscriber<? super T> call(Subscriber<? super T> child) {
-                final Subscriber<T> serial = new SerializedSubscriber<T>(child, false);
-
-                final Subscriber<T> main = new Subscriber<T>(serial, false) {
-                    @Override
-                    public void onNext(T t) {
-                        serial.onNext(t);
-                    }
-                    @Override
-                    public void onError(Throwable e) {
-                        try {
-                            serial.onError(e);
-                        } finally {
-                            serial.unsubscribe();
-                        }
-                    }
-                    @Override
-                    public void onCompleted() {
-                        try {
-                            serial.onCompleted();
-                        } finally {
-                            serial.unsubscribe();
-                        }
-                    }
-                };
-
-                final Subscriber<E> so = new Subscriber<E>() {
-
-                    @Override
-                    public void onCompleted() {
-                        onError(new CancellationException("Stream was canceled before emitting a terminal event."));
-                    }
-
-                    @Override
-                    public void onError(Throwable e) {
-                        main.onError(e);
-                    }
-
-                    @Override
-                    public void onNext(E e) {
-                        onError(new CancellationException("Stream was canceled before emitting a terminal event."));
-                    }
-                };
-
-                serial.add(main);
-                serial.add(so);
-
-                child.add(serial);
-
-                other.unsafeSubscribe(so);
-
-                return main;
-            }
-        });
+        return create(new SingleTakeUntilObservable<T, E>(onSubscribe, other));
     }
 
     /**
@@ -2131,56 +1938,7 @@ public void onNext(E e) {
      * @see <a href="http://reactivex.io/documentation/operators/takeuntil.html">ReactiveX operators documentation: TakeUntil</a>
      */
     public final <E> Single<T> takeUntil(final Single<? extends E> other) {
-        return lift(new Operator<T, T>() {
-            @Override
-            public Subscriber<? super T> call(Subscriber<? super T> child) {
-                final Subscriber<T> serial = new SerializedSubscriber<T>(child, false);
-
-                final Subscriber<T> main = new Subscriber<T>(serial, false) {
-                    @Override
-                    public void onNext(T t) {
-                        serial.onNext(t);
-                    }
-                    @Override
-                    public void onError(Throwable e) {
-                        try {
-                            serial.onError(e);
-                        } finally {
-                            serial.unsubscribe();
-                        }
-                    }
-                    @Override
-                    public void onCompleted() {
-                        try {
-                            serial.onCompleted();
-                        } finally {
-                            serial.unsubscribe();
-                        }
-                    }
-                };
-
-                final SingleSubscriber<E> so = new SingleSubscriber<E>() {
-                    @Override
-                    public void onSuccess(E value) {
-                        onError(new CancellationException("Stream was canceled before emitting a terminal event."));
-                    }
-
-                    @Override
-                    public void onError(Throwable e) {
-                        main.onError(e);
-                    }
-                };
-
-                serial.add(main);
-                serial.add(so);
-
-                child.add(serial);
-
-                other.subscribe(so);
-
-                return main;
-            }
-        });
+        return create(new SingleTakeUntilSingle<T, E>(onSubscribe, other));
     }
 
     /**
@@ -2329,7 +2087,7 @@ public final Single<T> timeout(long timeout, TimeUnit timeUnit, Single<? extends
         if (other == null) {
             other = Single.<T> error(new TimeoutException());
         }
-        return lift(new OperatorTimeout<T>(timeout, timeUnit, asObservable(other), scheduler));
+        return create(new SingleTimeout<T>(onSubscribe, timeout, timeUnit, scheduler, other.onSubscribe));
     }
 
     /**
@@ -2462,17 +2220,8 @@ public final Single<T> doOnSuccess(final Action1<? super T> onSuccess) {
             throw new IllegalArgumentException("onSuccess is null");
         }
 
-        return Single.create(new SingleDoOnEvent<T>(this, new Action1<T>() {
-            @Override
-            public void call(final T t) {
-                onSuccess.call(t);
-            }
-        }, new Action1<Throwable>() {
-            @Override
-            public void call(final Throwable throwable) {
-                // Do nothing.
-            }
-        }));
+        Action1<Throwable> empty = Actions.empty();
+        return Single.create(new SingleDoOnEvent<T>(this, onSuccess, empty));
     }
 
     /**
@@ -2495,7 +2244,7 @@ public void call(final Throwable throwable) {
      */
     @Beta
     public final Single<T> doOnSubscribe(final Action0 subscribe) {
-        return lift(new OperatorDoOnSubscribe<T>(subscribe));
+        return create(new SingleDoOnSubscribe<T>(onSubscribe, subscribe));
     }
 
     /**
@@ -2520,7 +2269,7 @@ public final Single<T> doOnSubscribe(final Action0 subscribe) {
      */
     @Beta
     public final Single<T> delay(long delay, TimeUnit unit, Scheduler scheduler) {
-        return lift(new OperatorDelay<T>(delay, unit, scheduler));
+        return create(new SingleDelay<T>(onSubscribe, delay, unit, scheduler));
     }
 
     /**
@@ -2609,7 +2358,7 @@ public void call(SingleSubscriber<? super T> singleSubscriber) {
      */
     @Beta
     public final Single<T> doOnUnsubscribe(final Action0 action) {
-        return lift(new OperatorDoOnUnsubscribe<T>(action));
+        return create(new SingleDoOnUnsubscribe<T>(onSubscribe, action));
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/CompletableFromEmitter.java b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
index eca4c3bc0c..5bbc02c95d 100644
--- a/src/main/java/rx/internal/operators/CompletableFromEmitter.java
+++ b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
@@ -28,6 +28,7 @@
 /**
  * Allows push-based emission of terminal events to a CompletableSubscriber.
  */
+@SuppressWarnings("deprecation")
 public final class CompletableFromEmitter implements Completable.OnSubscribe {
 
     final Action1<CompletableEmitter> producer;
diff --git a/src/main/java/rx/internal/operators/NotificationLite.java b/src/main/java/rx/internal/operators/NotificationLite.java
index fad576e8e1..57a64d1f2b 100644
--- a/src/main/java/rx/internal/operators/NotificationLite.java
+++ b/src/main/java/rx/internal/operators/NotificationLite.java
@@ -75,6 +75,7 @@ public String toString() {
      * Creates a lite {@code onNext} notification for the value passed in without doing any allocation. Can
      * be unwrapped and sent with the {@link #accept} method.
      *
+     * @param <T> the value type to convert
      * @param t
      *          the item emitted to {@code onNext}
      * @return the item, or a null token representing the item if the item is {@code null}
@@ -113,6 +114,7 @@ public static Object error(Throwable e) {
     /**
      * Unwraps the lite notification and calls the appropriate method on the {@link Observer}.
      *
+     * @param <T> the value type to accept
      * @param o
      *            the {@link Observer} to call {@code onNext}, {@code onCompleted}, or {@code onError}.
      * @param n
@@ -212,6 +214,7 @@ public static Kind kind(Object n) {
      * this an {@code OnComplete} or {@code OnError} notification type. For performance reasons, this method
      * does not check for this, so you are expected to prevent such a mishap.
      *
+     * @param <T> the value type to convert
      * @param n
      *            the lite notification (of type {@code Kind.OnNext})
      * @return the unwrapped value, which can be null
diff --git a/src/main/java/rx/internal/operators/SingleDelay.java b/src/main/java/rx/internal/operators/SingleDelay.java
new file mode 100644
index 0000000000..512893f156
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleDelay.java
@@ -0,0 +1,109 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.TimeUnit;
+
+import rx.*;
+import rx.Scheduler.Worker;
+import rx.Single.OnSubscribe;
+import rx.functions.Action0;
+
+/**
+ * Signal the success or error value on the Scheduler's thread.
+ *
+ * @param <T> the value type
+ */
+public final class SingleDelay<T> implements Single.OnSubscribe<T> {
+
+    final Single.OnSubscribe<T> source;
+
+    final long delay;
+
+    final TimeUnit unit;
+
+    final Scheduler scheduler;
+
+    public SingleDelay(OnSubscribe<T> source, long delay, TimeUnit unit, Scheduler scheduler) {
+        this.source = source;
+        this.scheduler = scheduler;
+        this.delay = delay;
+        this.unit = unit;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        Worker w = scheduler.createWorker();
+
+        ObserveOnSingleSubscriber<T> parent = new ObserveOnSingleSubscriber<T>(t, w, delay, unit);
+
+        t.add(w);
+        t.add(parent);
+
+        source.call(parent);
+    }
+
+    static final class ObserveOnSingleSubscriber<T> extends SingleSubscriber<T>
+    implements Action0 {
+        final SingleSubscriber<? super T> actual;
+
+        final Worker w;
+
+        final long delay;
+
+        final TimeUnit unit;
+
+        T value;
+        Throwable error;
+
+        public ObserveOnSingleSubscriber(SingleSubscriber<? super T> actual, Worker w, long delay, TimeUnit unit) {
+            this.actual = actual;
+            this.w = w;
+            this.delay = delay;
+            this.unit = unit;
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            this.value = value;
+            w.schedule(this, delay, unit);
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            this.error = error;
+            w.schedule(this, delay, unit);
+        }
+
+        @Override
+        public void call() {
+            try {
+                Throwable ex = error;
+                if (ex != null) {
+                    error = null;
+                    actual.onError(ex);
+                } else {
+                    T v = value;
+                    value = null;
+                    actual.onSuccess(v);
+                }
+            } finally {
+                w.unsubscribe();
+            }
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleDoOnSubscribe.java b/src/main/java/rx/internal/operators/SingleDoOnSubscribe.java
new file mode 100644
index 0000000000..5731e232ef
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleDoOnSubscribe.java
@@ -0,0 +1,52 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.exceptions.Exceptions;
+import rx.functions.Action0;
+
+/**
+ * Call an Action0 when the subscription happens to the source.
+ *
+ * @param <T> the value type
+ */
+public final class SingleDoOnSubscribe<T> implements Single.OnSubscribe<T> {
+
+    final Single.OnSubscribe<T> source;
+
+    final Action0 onSubscribe;
+
+    public SingleDoOnSubscribe(Single.OnSubscribe<T> source, Action0 onSubscribe) {
+        this.source = source;
+        this.onSubscribe = onSubscribe;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+
+        try {
+            onSubscribe.call();
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            t.onError(ex);
+            return;
+        }
+
+        source.call(t);
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleDoOnUnsubscribe.java b/src/main/java/rx/internal/operators/SingleDoOnUnsubscribe.java
new file mode 100644
index 0000000000..72385811c1
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleDoOnUnsubscribe.java
@@ -0,0 +1,44 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.functions.Action0;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * Call an Action0 when the subscription happens to the source.
+ *
+ * @param <T> the value type
+ */
+public final class SingleDoOnUnsubscribe<T> implements Single.OnSubscribe<T> {
+
+    final Single.OnSubscribe<T> source;
+
+    final Action0 onUnsubscribe;
+
+    public SingleDoOnUnsubscribe(Single.OnSubscribe<T> source, Action0 onUnsubscribe) {
+        this.source = source;
+        this.onUnsubscribe = onUnsubscribe;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        t.add(Subscriptions.create(onUnsubscribe));
+        source.call(t);
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleFromCallable.java b/src/main/java/rx/internal/operators/SingleFromCallable.java
new file mode 100644
index 0000000000..2e8f6940b2
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleFromCallable.java
@@ -0,0 +1,50 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.Callable;
+
+import rx.*;
+import rx.exceptions.Exceptions;
+
+/**
+ * Execute a callable and emit its resulting value.
+ *
+ * @param <T> the value type
+ */
+public final class SingleFromCallable<T> implements Single.OnSubscribe<T> {
+
+    final Callable<? extends T> callable;
+
+    public SingleFromCallable(Callable<? extends T> callable) {
+        this.callable = callable;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        T v;
+        try {
+            v = callable.call();
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            t.onError(ex);
+            return;
+        }
+
+        t.onSuccess(v);
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleFromFuture.java b/src/main/java/rx/internal/operators/SingleFromFuture.java
new file mode 100644
index 0000000000..cf66161e4a
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleFromFuture.java
@@ -0,0 +1,66 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.*;
+
+import rx.*;
+import rx.exceptions.Exceptions;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * Wait and emit the value of the Future.
+ *
+ * @param <T> the value type
+ */
+public final class SingleFromFuture<T> implements Single.OnSubscribe<T> {
+
+    final Future<? extends T> future;
+
+    final long timeout;
+
+    final TimeUnit unit;
+
+    public SingleFromFuture(Future<? extends T> future, long timeout, TimeUnit unit) {
+        this.future = future;
+        this.timeout = timeout;
+        this.unit = unit;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        Future<? extends T> f = future;
+
+        t.add(Subscriptions.from(f));
+
+        T v;
+
+        try {
+            if (timeout == 0L) {
+                v = f.get();
+            } else {
+                v = f.get(timeout, unit);
+            }
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            t.onError(ex);
+            return;
+        }
+
+        t.onSuccess(v);
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleFromObservable.java b/src/main/java/rx/internal/operators/SingleFromObservable.java
new file mode 100644
index 0000000000..ec6a82e35c
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleFromObservable.java
@@ -0,0 +1,94 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.NoSuchElementException;
+
+import rx.*;
+import rx.Observable.OnSubscribe;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Wrap an Observable.OnSubscribe and expose it as a Single.OnSubscribe.
+ *
+ * @param <T> the value type
+ */
+public final class SingleFromObservable<T> implements Single.OnSubscribe<T> {
+
+    final Observable.OnSubscribe<T> source;
+
+    public SingleFromObservable(OnSubscribe<T> source) {
+        this.source = source;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        WrapSingleIntoSubscriber<T> parent = new WrapSingleIntoSubscriber<T>(t);
+        t.add(parent);
+        source.call(parent);
+    }
+
+    static final class WrapSingleIntoSubscriber<T> extends Subscriber<T> {
+
+        final SingleSubscriber<? super T> actual;
+
+        T value;
+        int state;
+
+        static final int STATE_EMPTY = 0;
+        static final int STATE_HAS_VALUE = 1;
+        static final int STATE_DONE = 2;
+
+        WrapSingleIntoSubscriber(SingleSubscriber<? super T> actual) {
+            this.actual = actual;
+        }
+
+        @Override
+        public void onNext(T t) {
+            int s = state;
+            if (s == STATE_EMPTY) {
+                state = STATE_HAS_VALUE;
+                value = t;
+            } else if (s == STATE_HAS_VALUE) {
+                state = STATE_DONE;
+                actual.onError(new IndexOutOfBoundsException("The upstream produced more than one value"));
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            if (state == STATE_DONE) {
+                RxJavaHooks.onError(e);
+            } else {
+                value = null;
+                actual.onError(e);
+            }
+        }
+
+        @Override
+        public void onCompleted() {
+            int s = state;
+            if (s == STATE_EMPTY) {
+                actual.onError(new NoSuchElementException());
+            } else if (s == STATE_HAS_VALUE) {
+                state = STATE_DONE;
+                T v = value;
+                value = null;
+                actual.onSuccess(v);
+            }
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleLiftObservableOperator.java b/src/main/java/rx/internal/operators/SingleLiftObservableOperator.java
new file mode 100644
index 0000000000..921210fc87
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleLiftObservableOperator.java
@@ -0,0 +1,84 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.Observable.Operator;
+import rx.Single.OnSubscribe;
+import rx.exceptions.Exceptions;
+import rx.internal.operators.SingleFromObservable.WrapSingleIntoSubscriber;
+import rx.internal.producers.SingleProducer;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Lift an Observable.Operator into the Single sequence.
+ * @param <T> the input value type
+ * @param <R> the output value type
+ */
+public final class SingleLiftObservableOperator<T, R> implements Single.OnSubscribe<R> {
+
+    final Single.OnSubscribe<T> source;
+
+    final Operator<? extends R, ? super T> lift;
+
+    public SingleLiftObservableOperator(OnSubscribe<T> source, Operator<? extends R, ? super T> lift) {
+        this.source = source;
+        this.lift = lift;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super R> t) {
+        Subscriber<R> outputAsSubscriber = new WrapSingleIntoSubscriber<R>(t);
+        t.add(outputAsSubscriber);
+
+        try {
+            Subscriber<? super T> inputAsSubscriber = RxJavaHooks.onSingleLift(lift).call(outputAsSubscriber);
+
+            SingleSubscriber<? super T> input = wrap(inputAsSubscriber);
+
+            inputAsSubscriber.onStart();
+
+            source.call(input);
+        } catch (Throwable ex) {
+            Exceptions.throwOrReport(ex, t);
+        }
+    }
+
+    public static <T> SingleSubscriber<T> wrap(Subscriber<T> subscriber) {
+        WrapSubscriberIntoSingle<T> parent = new WrapSubscriberIntoSingle<T>(subscriber);
+        subscriber.add(parent);
+        return parent;
+    }
+
+    static final class WrapSubscriberIntoSingle<T> extends SingleSubscriber<T> {
+        final Subscriber<? super T> actual;
+
+        WrapSubscriberIntoSingle(Subscriber<? super T> actual) {
+            this.actual = actual;
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            actual.setProducer(new SingleProducer<T>(actual, value));
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            actual.onError(error);
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleObserveOn.java b/src/main/java/rx/internal/operators/SingleObserveOn.java
new file mode 100644
index 0000000000..dc9c2fc299
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleObserveOn.java
@@ -0,0 +1,95 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.Scheduler.Worker;
+import rx.Single.OnSubscribe;
+import rx.functions.Action0;
+
+/**
+ * Signal the success or error value on the Scheduler's thread.
+ *
+ * @param <T> the value type
+ */
+public final class SingleObserveOn<T> implements Single.OnSubscribe<T> {
+
+    final Single.OnSubscribe<T> source;
+
+    final Scheduler scheduler;
+
+    public SingleObserveOn(OnSubscribe<T> source, Scheduler scheduler) {
+        this.source = source;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        Worker w = scheduler.createWorker();
+
+        ObserveOnSingleSubscriber<T> parent = new ObserveOnSingleSubscriber<T>(t, w);
+
+        t.add(w);
+        t.add(parent);
+
+        source.call(parent);
+    }
+
+    static final class ObserveOnSingleSubscriber<T> extends SingleSubscriber<T>
+    implements Action0 {
+        final SingleSubscriber<? super T> actual;
+
+        final Worker w;
+
+        T value;
+        Throwable error;
+
+        public ObserveOnSingleSubscriber(SingleSubscriber<? super T> actual, Worker w) {
+            this.actual = actual;
+            this.w = w;
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            this.value = value;
+            w.schedule(this);
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            this.error = error;
+            w.schedule(this);
+        }
+
+        @Override
+        public void call() {
+            try {
+                Throwable ex = error;
+                if (ex != null) {
+                    error = null;
+                    actual.onError(ex);
+                } else {
+                    T v = value;
+                    value = null;
+                    actual.onSuccess(v);
+                }
+            } finally {
+                w.unsubscribe();
+            }
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleOnErrorReturn.java b/src/main/java/rx/internal/operators/SingleOnErrorReturn.java
new file mode 100644
index 0000000000..124a24dfd7
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleOnErrorReturn.java
@@ -0,0 +1,79 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.Single.OnSubscribe;
+import rx.exceptions.Exceptions;
+import rx.functions.Func1;
+
+/**
+ * Signal a value returned by a resumeFunction when the source signals a Throwable.
+ *
+ * @param <T> the value type
+ */
+public final class SingleOnErrorReturn<T> implements Single.OnSubscribe<T> {
+
+    final Single.OnSubscribe<T> source;
+
+    final Func1<Throwable, ? extends T> resumeFunction;
+
+    public SingleOnErrorReturn(OnSubscribe<T> source, Func1<Throwable, ? extends T> resumeFunction) {
+        this.source = source;
+        this.resumeFunction = resumeFunction;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        OnErrorReturnsSingleSubscriber<T> parent = new OnErrorReturnsSingleSubscriber<T>(t, resumeFunction);
+        t.add(parent);
+        source.call(parent);
+    }
+
+    static final class OnErrorReturnsSingleSubscriber<T> extends SingleSubscriber<T> {
+
+        final SingleSubscriber<? super T> actual;
+
+        final Func1<Throwable, ? extends T> resumeFunction;
+
+        public OnErrorReturnsSingleSubscriber(SingleSubscriber<? super T> actual,
+                Func1<Throwable, ? extends T> resumeFunction) {
+            this.actual = actual;
+            this.resumeFunction = resumeFunction;
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            actual.onSuccess(value);
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            T v;
+
+            try {
+                v = resumeFunction.call(error);
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                actual.onError(ex);
+                return;
+            }
+
+            actual.onSuccess(v);
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleTakeUntilCompletable.java b/src/main/java/rx/internal/operators/SingleTakeUntilCompletable.java
new file mode 100644
index 0000000000..28110ade31
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleTakeUntilCompletable.java
@@ -0,0 +1,92 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import rx.*;
+import rx.Single.OnSubscribe;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Relay the source signals if the other doesn't terminate before.
+ *
+ * @param <T> the value type
+ */
+public final class SingleTakeUntilCompletable<T> implements Single.OnSubscribe<T> {
+
+    final Single.OnSubscribe<T> source;
+
+    final Completable other;
+
+    public SingleTakeUntilCompletable(OnSubscribe<T> source, Completable other) {
+        this.source = source;
+        this.other = other;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        TakeUntilSourceSubscriber<T> parent = new TakeUntilSourceSubscriber<T>(t);
+        t.add(parent);
+
+        other.subscribe(parent);
+        source.call(parent);
+    }
+
+    static final class TakeUntilSourceSubscriber<T> extends SingleSubscriber<T>
+    implements CompletableSubscriber {
+
+        final SingleSubscriber<? super T> actual;
+
+        final AtomicBoolean once;
+
+        TakeUntilSourceSubscriber(SingleSubscriber<? super T> actual) {
+            this.actual = actual;
+            this.once = new AtomicBoolean();
+        }
+
+        @Override
+        public void onSubscribe(Subscription d) {
+            add(d);
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            if (once.compareAndSet(false, true)) {
+                unsubscribe();
+
+                actual.onSuccess(value);
+            }
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            if (once.compareAndSet(false, true)) {
+                unsubscribe();
+                actual.onError(error);
+            } else {
+                RxJavaHooks.onError(error);
+            }
+        }
+
+        @Override
+        public void onCompleted() {
+            onError(new CancellationException("Stream was canceled before emitting a terminal event."));
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleTakeUntilObservable.java b/src/main/java/rx/internal/operators/SingleTakeUntilObservable.java
new file mode 100644
index 0000000000..81764449c4
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleTakeUntilObservable.java
@@ -0,0 +1,103 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import rx.*;
+import rx.Single.OnSubscribe;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Relay the source signals if the other doesn't terminate before.
+ *
+ * @param <T> the value type
+ * @param <U> the other's value type (not relevant)
+ */
+public final class SingleTakeUntilObservable<T, U> implements Single.OnSubscribe<T> {
+
+    final Single.OnSubscribe<T> source;
+
+    final Observable<? extends U> other;
+
+    public SingleTakeUntilObservable(OnSubscribe<T> source, Observable<? extends U> other) {
+        this.source = source;
+        this.other = other;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        TakeUntilSourceSubscriber<T, U> parent = new TakeUntilSourceSubscriber<T, U>(t);
+        t.add(parent);
+
+        other.subscribe(parent.other);
+        source.call(parent);
+    }
+
+    static final class TakeUntilSourceSubscriber<T, U> extends SingleSubscriber<T> {
+
+        final SingleSubscriber<? super T> actual;
+
+        final AtomicBoolean once;
+
+        final Subscriber<U> other;
+
+        TakeUntilSourceSubscriber(SingleSubscriber<? super T> actual) {
+            this.actual = actual;
+            this.once = new AtomicBoolean();
+            this.other = new OtherSubscriber();
+            add(other);
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            if (once.compareAndSet(false, true)) {
+                unsubscribe();
+
+                actual.onSuccess(value);
+            }
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            if (once.compareAndSet(false, true)) {
+                unsubscribe();
+                actual.onError(error);
+            } else {
+                RxJavaHooks.onError(error);
+            }
+        }
+
+        final class OtherSubscriber extends Subscriber<U> {
+            @Override
+            public void onNext(U value) {
+                onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable error) {
+                TakeUntilSourceSubscriber.this.onError(error);
+            }
+
+            @Override
+            public void onCompleted() {
+                onError(new CancellationException("Stream was canceled before emitting a terminal event."));
+            }
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleTakeUntilSingle.java b/src/main/java/rx/internal/operators/SingleTakeUntilSingle.java
new file mode 100644
index 0000000000..05dfc00efc
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleTakeUntilSingle.java
@@ -0,0 +1,98 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import rx.*;
+import rx.Single.OnSubscribe;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Relay the source signals if the other doesn't terminate before.
+ *
+ * @param <T> the value type
+ * @param <U> the other's value type (not relevant)
+ */
+public final class SingleTakeUntilSingle<T, U> implements Single.OnSubscribe<T> {
+
+    final Single.OnSubscribe<T> source;
+
+    final Single<? extends U> other;
+
+    public SingleTakeUntilSingle(OnSubscribe<T> source, Single<? extends U> other) {
+        this.source = source;
+        this.other = other;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        TakeUntilSourceSubscriber<T, U> parent = new TakeUntilSourceSubscriber<T, U>(t);
+        t.add(parent);
+
+        other.subscribe(parent.other);
+        source.call(parent);
+    }
+
+    static final class TakeUntilSourceSubscriber<T, U> extends SingleSubscriber<T> {
+
+        final SingleSubscriber<? super T> actual;
+
+        final AtomicBoolean once;
+
+        final SingleSubscriber<U> other;
+
+        TakeUntilSourceSubscriber(SingleSubscriber<? super T> actual) {
+            this.actual = actual;
+            this.once = new AtomicBoolean();
+            this.other = new OtherSubscriber();
+            add(other);
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            if (once.compareAndSet(false, true)) {
+                unsubscribe();
+
+                actual.onSuccess(value);
+            }
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            if (once.compareAndSet(false, true)) {
+                unsubscribe();
+                actual.onError(error);
+            } else {
+                RxJavaHooks.onError(error);
+            }
+        }
+
+        final class OtherSubscriber extends SingleSubscriber<U> {
+            @Override
+            public void onSuccess(U value) {
+                onError(new CancellationException("Stream was canceled before emitting a terminal event."));
+            }
+
+            @Override
+            public void onError(Throwable error) {
+                TakeUntilSourceSubscriber.this.onError(error);
+            }
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleTimeout.java b/src/main/java/rx/internal/operators/SingleTimeout.java
new file mode 100644
index 0000000000..9376ada95e
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleTimeout.java
@@ -0,0 +1,137 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import rx.*;
+import rx.functions.Action0;
+import rx.plugins.RxJavaHooks;
+
+public final class SingleTimeout<T> implements Single.OnSubscribe<T> {
+
+    final Single.OnSubscribe<T> source;
+
+    final long timeout;
+
+    final TimeUnit unit;
+
+    final Scheduler scheduler;
+
+    final Single.OnSubscribe<? extends T> other;
+
+    public SingleTimeout(Single.OnSubscribe<T> source, long timeout, TimeUnit unit, Scheduler scheduler,
+            Single.OnSubscribe<? extends T> other) {
+        this.source = source;
+        this.timeout = timeout;
+        this.unit = unit;
+        this.scheduler = scheduler;
+        this.other = other;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        TimeoutSingleSubscriber<T> parent = new TimeoutSingleSubscriber<T>(t, other);
+
+        Scheduler.Worker w = scheduler.createWorker();
+        parent.add(w);
+
+        t.add(parent);
+
+        w.schedule(parent, timeout, unit);
+
+        source.call(parent);
+    }
+
+    static final class TimeoutSingleSubscriber<T> extends SingleSubscriber<T> implements Action0 {
+
+        final SingleSubscriber<? super T> actual;
+
+        final AtomicBoolean once;
+
+        final Single.OnSubscribe<? extends T> other;
+
+        TimeoutSingleSubscriber(SingleSubscriber<? super T> actual, Single.OnSubscribe<? extends T> other) {
+            this.actual = actual;
+            this.other = other;
+            this.once = new AtomicBoolean();
+        }
+
+        @Override
+        public void onSuccess(T value) {
+            if (once.compareAndSet(false, true)) {
+                try {
+                    actual.onSuccess(value);
+                } finally {
+                    unsubscribe();
+                }
+            }
+        }
+
+        @Override
+        public void onError(Throwable error) {
+            if (once.compareAndSet(false, true)) {
+                try {
+                    actual.onError(error);
+                } finally {
+                    unsubscribe();
+                }
+            } else {
+                RxJavaHooks.onError(error);
+            }
+        }
+
+        @Override
+        public void call() {
+            if (once.compareAndSet(false, true)) {
+                try {
+                    Single.OnSubscribe<? extends T> o = other;
+
+                    if (o == null) {
+                        actual.onError(new TimeoutException());
+                    } else {
+                        OtherSubscriber<T> p = new OtherSubscriber<T>(actual);
+                        actual.add(p);
+                        o.call(p);
+                    }
+                } finally {
+                    unsubscribe();
+                }
+            }
+        }
+
+        static final class OtherSubscriber<T> extends SingleSubscriber<T> {
+
+            final SingleSubscriber<? super T> actual;
+
+            OtherSubscriber(SingleSubscriber<? super T> actual) {
+                this.actual = actual;
+            }
+
+            @Override
+            public void onSuccess(T value) {
+                actual.onSuccess(value);
+            }
+
+            @Override
+            public void onError(Throwable error) {
+                actual.onError(error);
+            }
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/SingleToObservable.java b/src/main/java/rx/internal/operators/SingleToObservable.java
new file mode 100644
index 0000000000..50d9a9cf0e
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleToObservable.java
@@ -0,0 +1,41 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.*;
+import rx.internal.operators.SingleLiftObservableOperator.WrapSubscriberIntoSingle;
+
+/**
+ * Expose a Single.OnSubscribe as an Observable.OnSubscribe.
+ *
+ * @param <T> the value type
+ */
+public final class SingleToObservable<T> implements Observable.OnSubscribe<T> {
+
+    final Single.OnSubscribe<T> source;
+
+    public SingleToObservable(Single.OnSubscribe<T> source) {
+        this.source = source;
+    }
+
+    @Override
+    public void call(Subscriber<? super T> t) {
+        WrapSubscriberIntoSingle<T> parent = new WrapSubscriberIntoSingle<T>(t);
+        t.add(parent);
+        source.call(parent);
+    }
+}
diff --git a/src/main/java/rx/internal/util/ScalarSynchronousSingle.java b/src/main/java/rx/internal/util/ScalarSynchronousSingle.java
index 2a0844ca28..461f6e1c3b 100644
--- a/src/main/java/rx/internal/util/ScalarSynchronousSingle.java
+++ b/src/main/java/rx/internal/util/ScalarSynchronousSingle.java
@@ -15,13 +15,9 @@
  */
 package rx.internal.util;
 
-import rx.Scheduler;
+import rx.*;
 import rx.Scheduler.Worker;
-import rx.Single;
-import rx.SingleSubscriber;
-import rx.Subscriber;
-import rx.functions.Action0;
-import rx.functions.Func1;
+import rx.functions.*;
 import rx.internal.schedulers.EventLoopsScheduler;
 
 public final class ScalarSynchronousSingle<T> extends Single<T> {
@@ -133,24 +129,19 @@ public void call(final SingleSubscriber<? super R> child) {
                 if (o instanceof ScalarSynchronousSingle) {
                     child.onSuccess(((ScalarSynchronousSingle<? extends R>) o).value);
                 } else {
-                    Subscriber<R> subscriber = new Subscriber<R>() {
-                        @Override
-                        public void onCompleted() {
-                            // deliberately ignored
-                        }
-
+                    SingleSubscriber<R> subscriber = new SingleSubscriber<R>() {
                         @Override
                         public void onError(Throwable e) {
                             child.onError(e);
                         }
 
                         @Override
-                        public void onNext(R r) {
+                        public void onSuccess(R r) {
                             child.onSuccess(r);
                         }
                     };
                     child.add(subscriber);
-                    o.unsafeSubscribe(subscriber);
+                    o.subscribe(subscriber);
                 }
             }
         });
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index 159da16771..0cac048984 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -51,7 +51,7 @@ public final class RxJavaHooks {
     static volatile Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> onObservableStart;
 
     @SuppressWarnings("rawtypes")
-    static volatile Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> onSingleStart;
+    static volatile Func2<Single, Single.OnSubscribe, Single.OnSubscribe> onSingleStart;
 
     static volatile Func2<Completable, Completable.OnSubscribe, Completable.OnSubscribe> onCompletableStart;
 
@@ -120,10 +120,18 @@ public Subscription call(Subscription f) {
             }
         };
 
-        onSingleStart = new Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe>() {
+        onSingleStart = new Func2<Single, Single.OnSubscribe, Single.OnSubscribe>() {
             @Override
-            public Observable.OnSubscribe call(Single t1, Observable.OnSubscribe t2) {
-                return RxJavaPlugins.getInstance().getSingleExecutionHook().onSubscribeStart(t1, t2);
+            public Single.OnSubscribe call(Single t1, Single.OnSubscribe t2) {
+
+                RxJavaSingleExecutionHook hook = RxJavaPlugins.getInstance().getSingleExecutionHook();
+
+                if (hook == RxJavaSingleExecutionHookDefault.getInstance()) {
+                    return t2;
+                }
+
+                return new SingleFromObservable(hook.onSubscribeStart(t1,
+                        new SingleToObservable(t2)));
             }
         };
 
@@ -479,8 +487,8 @@ public static <T, R> Observable.Operator<R, T> onObservableLift(Observable.Opera
      * @return the original or alternative action that will be subscribed to
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
-    public static <T> Observable.OnSubscribe<T> onSingleStart(Single<T> instance, Observable.OnSubscribe<T> onSubscribe) {
-        Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> f = onSingleStart;
+    public static <T> Single.OnSubscribe<T> onSingleStart(Single<T> instance, Single.OnSubscribe<T> onSubscribe) {
+        Func2<Single, Single.OnSubscribe, Single.OnSubscribe> f = onSingleStart;
         if (f != null) {
             return f.call(instance, onSubscribe);
         }
@@ -770,7 +778,7 @@ public static void setOnObservableStart(
      * that gets actually subscribed to.
      */
     @SuppressWarnings("rawtypes")
-    public static void setOnSingleStart(Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> onSingleStart) {
+    public static void setOnSingleStart(Func2<Single, Single.OnSubscribe, Single.OnSubscribe> onSingleStart) {
         if (lockdown) {
             return;
         }
@@ -1115,7 +1123,7 @@ public static Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe>
      * @return the current hook function
      */
     @SuppressWarnings("rawtypes")
-    public static Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> getOnSingleStart() {
+    public static Func2<Single, Single.OnSubscribe, Single.OnSubscribe> getOnSingleStart() {
         return onSingleStart;
     }
 
diff --git a/src/test/java/rx/ObservableDoOnTest.java b/src/test/java/rx/ObservableDoOnTest.java
index 44c7ea6ef1..911426bb53 100644
--- a/src/test/java/rx/ObservableDoOnTest.java
+++ b/src/test/java/rx/ObservableDoOnTest.java
@@ -66,7 +66,7 @@ public void call(Throwable v) {
         assertNotNull(t);
         assertEquals(t, r.get());
     }
-    
+
     @Test
     public void testDoOnErrorWithActionOfTypeObject() {
         final AtomicReference<Boolean> r = new AtomicReference<Boolean>();
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index bf05ddd937..18f3520b3e 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -41,7 +41,7 @@ public class SingleTest {
     private Func1<Single.OnSubscribe, Single.OnSubscribe> onCreate;
 
     @SuppressWarnings("rawtypes")
-    private Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe> onStart;
+    private Func2<Single, Single.OnSubscribe, Single.OnSubscribe> onStart;
 
     private Func1<Subscription, Subscription> onReturn;
 
@@ -57,9 +57,9 @@ public Single.OnSubscribe call(Single.OnSubscribe t) {
 
         RxJavaHooks.setOnSingleCreate(onCreate);
 
-        onStart = spy(new Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe>() {
+        onStart = spy(new Func2<Single, Single.OnSubscribe, Single.OnSubscribe>() {
             @Override
-            public Observable.OnSubscribe call(Single t1, Observable.OnSubscribe t2) {
+            public Single.OnSubscribe call(Single t1, Single.OnSubscribe t2) {
                 return t2;
             }
         });
@@ -445,7 +445,7 @@ public void testHookSubscribeStart() {
         });
         single.subscribe(ts);
 
-        verify(onStart, times(1)).call(eq(single), any(Observable.OnSubscribe.class));
+        verify(onStart, times(1)).call(eq(single), any(Single.OnSubscribe.class));
     }
 
     @Test
@@ -458,7 +458,7 @@ public void testHookUnsafeSubscribeStart() {
         });
         single.unsafeSubscribe(ts);
 
-        verify(onStart, times(1)).call(eq(single), any(Observable.OnSubscribe.class));
+        verify(onStart, times(1)).call(eq(single), any(Single.OnSubscribe.class));
     }
 
     @Test
diff --git a/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java b/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
index 8d1600c69d..f3a5f3d9a7 100644
--- a/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
+++ b/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
@@ -29,6 +29,7 @@
 import rx.observers.TestSubscriber;
 import rx.subscriptions.BooleanSubscription;
 
+@SuppressWarnings("deprecation")
 public class CompletableFromEmitterTest {
 
     @Test
diff --git a/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java b/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
index de99e1f726..e471376e93 100644
--- a/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
@@ -141,7 +141,7 @@ public void setProducer(Producer p) {
             Assert.assertEquals(Arrays.asList(0L, 1L), requested);
         }
     }
-    
+
     @Test
     public void canCallDoOnRequestWithActionOfTypeObject() {
         final AtomicReference<Boolean> r = new AtomicReference<Boolean>();
diff --git a/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java b/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java
index f03d5cf5c1..61c2015b4e 100644
--- a/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java
+++ b/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java
@@ -289,7 +289,7 @@ public Single<String> call(Resource resource) {
                 .doOnSuccess(completion);
         observable.subscribe(observer);
 
-        assertEquals(Arrays.asList("disposed", "completed", "unsub"), events);
+        assertEquals(Arrays.asList("disposed", "completed"/*, "unsub"*/), events);
 
     }
 
@@ -314,7 +314,7 @@ public Single<String> call(Resource resource) {
                 .doOnSuccess(completion);
         observable.subscribe(observer);
 
-        assertEquals(Arrays.asList("completed", "unsub", "disposed"), events);
+        assertEquals(Arrays.asList("completed", /* "unsub",*/ "disposed"), events);
 
     }
 
@@ -341,7 +341,7 @@ public Single<String> call(Resource resource) {
                 .doOnError(onError);
         observable.subscribe(observer);
 
-        assertEquals(Arrays.asList("disposed", "error", "unsub"), events);
+        assertEquals(Arrays.asList("disposed", "error"/*, "unsub"*/), events);
 
     }
 
@@ -366,7 +366,7 @@ public Single<String> call(Resource resource) {
                 .doOnError(onError);
         observable.subscribe(observer);
 
-        assertEquals(Arrays.asList("error", "unsub", "disposed"), events);
+        assertEquals(Arrays.asList("error", /* "unsub",*/ "disposed"), events);
     }
 
     private static Action0 createUnsubAction(final List<String> events) {
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index a3b78678ef..023bb66175 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -31,7 +31,6 @@
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.internal.operators.OnSubscribeRange;
-import rx.internal.producers.SingleProducer;
 import rx.internal.util.UtilityFunctions;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
@@ -429,13 +428,13 @@ public void call(SingleSubscriber<? super Object> t) {
     @Test
     public void singleStart() {
         try {
-            RxJavaHooks.setOnSingleStart(new Func2<Single, Observable.OnSubscribe, Observable.OnSubscribe>() {
+            RxJavaHooks.setOnSingleStart(new Func2<Single, Single.OnSubscribe, Single.OnSubscribe>() {
                 @Override
-                public Observable.OnSubscribe call(Single o, Observable.OnSubscribe t) {
-                    return new Observable.OnSubscribe<Object>() {
+                public Single.OnSubscribe call(Single o, Single.OnSubscribe t) {
+                    return new Single.OnSubscribe<Object>() {
                         @Override
-                        public void call(Subscriber<? super Object> t) {
-                            t.setProducer(new SingleProducer<Integer>(t, 10));
+                        public void call(SingleSubscriber<? super Object> t) {
+                            t.onSuccess(10);
                         }
                     };
                 }
@@ -792,7 +791,7 @@ public void call(CompletableSubscriber t) {
 
             assertNull(RxJavaHooks.onSingleStart(Single.just(1), null));
 
-            assertSame(oos, RxJavaHooks.onSingleStart(Single.just(1), oos));
+            assertSame(sos, RxJavaHooks.onSingleStart(Single.just(1), sos));
 
             assertNull(RxJavaHooks.onCompletableStart(Completable.never(), null));
 

From e7bf7358426f5c38c0ecdc7ec69aac8cd49c8c8c Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 5 Oct 2016 09:12:04 +0200
Subject: [PATCH 178/263] 1.2.1 - Update changes.md

---
 CHANGES.md                                    | 21 +++++++++++++++++++
 src/test/java/rx/plugins/RxJavaHooksTest.java |  6 +++---
 2 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index a48700b7e9..17ba6a9a89 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,26 @@
 # RxJava Releases #
 
+### Version 1.2.1 - October 5, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.1%7C))
+
+#### API enhancements
+
+  - [Pull 4555](https://github.com/ReactiveX/RxJava/pull/4555): enhance generics of `doOnError` and `doOnRequest`
+  - [Pull 4580](https://github.com/ReactiveX/RxJava/pull/4580): rename `AsyncEmitter` to `Emitter`
+
+#### Performance enhancements
+
+  - [Pull 4621](https://github.com/ReactiveX/RxJava/pull/4621): `NotificationLite` - reduce allocations
+  - [Pull 4648](https://github.com/ReactiveX/RxJava/pull/4648): rework `Single` internals to reduce overhead and stack depth
+
+#### Deprecations
+
+  - [Pull 4580](https://github.com/ReactiveX/RxJava/pull/4580): `CompletableEmitter.setCancellation` will change its type in 1.2.2.
+  - [Pull 4648](https://github.com/ReactiveX/RxJava/pull/4648): Deprecate `Single(Observable.OnSubscribe)` constructor
+
+#### Bugfixes
+
+  - [Pull 4641](https://github.com/ReactiveX/RxJava/pull/4641): `SafeSubscriber` not to call `RxJavaHooks` before delivering the error
+
 ### Version 1.2.0 - September 17, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.0%7C))
 
 This is a minor release that is functionally equivalent to 1.1.10 minus the removal of some deprecated experimental APIs.
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index 023bb66175..3d9bdb7872 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -1087,18 +1087,18 @@ public Completable.Operator onLift(Completable.Operator lift) {
     public void noCallToHooksOnPlainError() {
 
         final boolean[] called = { false };
-        
+
         RxJavaHooks.setOnError(new Action1<Throwable>() {
             @Override
             public void call(Throwable t) {
                 called[0] = true;
             }
         });
-        
+
         try {
             Observable.error(new TestException())
             .subscribe(new TestSubscriber<Object>());
-            
+
             assertFalse(called[0]);
         } finally {
             RxJavaHooks.reset();

From e5b449d46f9c3240fc6eb59ed342bed15cc34e9e Mon Sep 17 00:00:00 2001
From: Jake Wharton <jakewharton@gmail.com>
Date: Thu, 6 Oct 2016 15:08:15 -0400
Subject: [PATCH 179/263] Cleanups from making NotificationLite stateless.
 (#4677)

---
 .../internal/operators/NotificationLite.java  | 32 +------------------
 1 file changed, 1 insertion(+), 31 deletions(-)

diff --git a/src/main/java/rx/internal/operators/NotificationLite.java b/src/main/java/rx/internal/operators/NotificationLite.java
index 57a64d1f2b..d5a988a6d8 100644
--- a/src/main/java/rx/internal/operators/NotificationLite.java
+++ b/src/main/java/rx/internal/operators/NotificationLite.java
@@ -17,7 +17,6 @@
 
 import java.io.Serializable;
 
-import rx.Notification.Kind;
 import rx.Observer;
 
 /**
@@ -28,15 +27,10 @@
  * <p>
  * An object is allocated inside {@link #error(Throwable)} to wrap the {@link Throwable} but this shouldn't
  * affect performance because exceptions should be exceptionally rare.
- * <p>
- * It's implemented as a singleton to maintain some semblance of type safety that is completely non-existent.
- *
- * @param <T> the element type
  */
-public final class NotificationLite<T> {
+public final class NotificationLite {
 
     private NotificationLite() {
-        // singleton
     }
 
     private static final Object ON_COMPLETED_SENTINEL = new Serializable() {
@@ -184,30 +178,6 @@ public static boolean isNull(Object n) {
     public static boolean isNext(Object n) {
         return n != null && !isError(n) && !isCompleted(n);
     }
-    /**
-     * Indicates which variety a particular lite notification is. If you need something more complex than
-     * simply calling the right method on an {@link Observer} then you can use this method to get the
-     * {@link rx.Notification.Kind}.
-     *
-     * @param n
-     *            the lite notification
-     * @throws IllegalArgumentException
-     *             if the notification is null.
-     * @return the {@link Kind} of lite notification {@code n} is: either {@code Kind.OnCompleted},
-     *         {@code Kind.OnError}, or {@code Kind.OnNext}
-     */
-    public static Kind kind(Object n) {
-        if (n == null) {
-            throw new IllegalArgumentException("The lite notification can not be null");
-        } else if (n == ON_COMPLETED_SENTINEL) {
-            return Kind.OnCompleted;
-        } else if (n instanceof OnErrorSentinel) {
-            return Kind.OnError;
-        } else {
-            // value or ON_NEXT_NULL_SENTINEL but either way it's an OnNext
-            return Kind.OnNext;
-        }
-    }
 
     /**
      * Returns the item corresponding to this {@code OnNext} lite notification. Bad things happen if you pass

From 09c289ea94b4a575b71f5df06ff8288884763b6c Mon Sep 17 00:00:00 2001
From: Jake Wharton <jakewharton@gmail.com>
Date: Thu, 6 Oct 2016 15:08:58 -0400
Subject: [PATCH 180/263] Make identity function a singleton. (#4676)

---
 .../java/rx/internal/util/UtilityFunctions.java | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/main/java/rx/internal/util/UtilityFunctions.java b/src/main/java/rx/internal/util/UtilityFunctions.java
index f70b8c295b..2b8f306a16 100644
--- a/src/main/java/rx/internal/util/UtilityFunctions.java
+++ b/src/main/java/rx/internal/util/UtilityFunctions.java
@@ -50,13 +50,9 @@ public static <T> Func1<? super T, Boolean> alwaysFalse() {
      * @param <T> the input and output value type
      * @return a {@link Func1} that accepts an Object and returns the same Object
      */
+    @SuppressWarnings("unchecked")
     public static <T> Func1<T, T> identity() {
-        return new Func1<T, T>() {
-            @Override
-            public T call(T o) {
-                return o;
-            }
-        };
+        return (Func1<T, T>) Identity.INSTANCE;
     }
 
     enum AlwaysTrue implements Func1<Object, Boolean> {
@@ -76,4 +72,13 @@ public Boolean call(Object o) {
             return false;
         }
     }
+
+    enum Identity implements Func1<Object, Object> {
+        INSTANCE;
+
+        @Override
+        public Object call(Object o) {
+            return o;
+        }
+    }
 }

From 1ac583435308aa354a2f82101cb4815313f2cfd8 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Wed, 12 Oct 2016 18:06:54 +1100
Subject: [PATCH 181/263] improve timer javadoc (#4693)

---
 src/main/java/rx/Observable.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index b3872d847d..a84498ac93 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -3750,7 +3750,7 @@ public static Observable<Long> timer(long initialDelay, long period, TimeUnit un
     }
 
     /**
-     * Returns an Observable that emits one item after a specified delay, and then completes.
+     * Returns an Observable that emits {@code 0L} after a specified delay, and then completes.
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timer.png" alt="">
      * <dl>
@@ -3773,7 +3773,7 @@ public static Observable<Long> timer(long delay, TimeUnit unit) {
     }
 
     /**
-     * Returns an Observable that emits one item after a specified delay, on a specified Scheduler, and then
+     * Returns an Observable that emits {@code 0L} after a specified delay, on a specified Scheduler, and then
      * completes.
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/timer.s.png" alt="">

From 6cc16464d1f6ac0676bbe0613fbce7cd9c532955 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Mon, 17 Oct 2016 19:16:45 +0200
Subject: [PATCH 182/263] 1.x: fix subscribe(Action1 [, Action1]) to report
 isUnsubscribed (#4716)

---
 src/main/java/rx/Single.java            | 44 +++++++----------------
 src/main/java/rx/functions/Actions.java | 18 ++++++++++
 src/test/java/rx/SingleTest.java        | 47 +++++++++++++++++++++++++
 3 files changed, 77 insertions(+), 32 deletions(-)

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 5095143c2e..5ee58d8f8d 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -1535,19 +1535,7 @@ public final Single<T> onErrorResumeNext(final Func1<Throwable, ? extends Single
      * @see <a href="http://reactivex.io/documentation/operators/subscribe.html">ReactiveX operators documentation: Subscribe</a>
      */
     public final Subscription subscribe() {
-        return subscribe(new SingleSubscriber<T>() {
-
-            @Override
-            public final void onError(Throwable e) {
-                throw new OnErrorNotImplementedException(e);
-            }
-
-            @Override
-            public final void onSuccess(T args) {
-                // do nothing
-            }
-
-        });
+        return subscribe(Actions.empty(), Actions.errorNotImplemented());
     }
 
     /**
@@ -1567,23 +1555,7 @@ public final void onSuccess(T args) {
      * @see <a href="http://reactivex.io/documentation/operators/subscribe.html">ReactiveX operators documentation: Subscribe</a>
      */
     public final Subscription subscribe(final Action1<? super T> onSuccess) {
-        if (onSuccess == null) {
-            throw new IllegalArgumentException("onSuccess can not be null");
-        }
-
-        return subscribe(new SingleSubscriber<T>() {
-
-            @Override
-            public final void onError(Throwable e) {
-                throw new OnErrorNotImplementedException(e);
-            }
-
-            @Override
-            public final void onSuccess(T args) {
-                onSuccess.call(args);
-            }
-
-        });
+        return subscribe(onSuccess, Actions.errorNotImplemented());
     }
 
     /**
@@ -1617,12 +1589,20 @@ public final Subscription subscribe(final Action1<? super T> onSuccess, final Ac
 
             @Override
             public final void onError(Throwable e) {
-                onError.call(e);
+                try {
+                    onError.call(e);
+                } finally {
+                    unsubscribe();
+                }
             }
 
             @Override
             public final void onSuccess(T args) {
-                onSuccess.call(args);
+                try {
+                    onSuccess.call(args);
+                } finally {
+                    unsubscribe();
+                }
             }
 
         });
diff --git a/src/main/java/rx/functions/Actions.java b/src/main/java/rx/functions/Actions.java
index 31e9826aa4..91a8c4db0f 100644
--- a/src/main/java/rx/functions/Actions.java
+++ b/src/main/java/rx/functions/Actions.java
@@ -15,6 +15,8 @@
  */
 package rx.functions;
 
+import rx.exceptions.OnErrorNotImplementedException;
+
 /**
  * Utility class for the Action interfaces.
  */
@@ -566,4 +568,20 @@ public void call(T t) {
             action.call();
         }
     }
+
+    enum NotImplemented implements Action1<Throwable> {
+        INSTANCE;
+        @Override
+        public void call(Throwable t) {
+            throw new OnErrorNotImplementedException(t);
+        }
+    }
+
+    /**
+     * Returns an action which throws OnErrorNotImplementedException.
+     * @return the the shared action
+     */
+    public static Action1<Throwable> errorNotImplemented() {
+        return NotImplemented.INSTANCE;
+    }
 }
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index 18f3520b3e..ef8bd0995e 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -2136,4 +2136,51 @@ public void call(final Notification<? extends Integer> notification) {
 
         assertEquals(1, atomicInteger.get());
     }
+
+    @Test
+    public void isUnsubscribedAfterSuccess() {
+        PublishSubject<Integer> ps = PublishSubject.create();
+
+        final int[] calls = { 0 };
+
+        Subscription s = ps.toSingle().subscribe(new Action1<Integer>() {
+            @Override
+            public void call(Integer t) {
+                calls[0]++;
+            }
+        });
+
+        assertFalse(s.isUnsubscribed());
+
+        ps.onNext(1);
+        ps.onCompleted();
+
+        assertTrue(s.isUnsubscribed());
+
+        assertEquals(1, calls[0]);
+    }
+
+    @Test
+    public void isUnsubscribedAfterError() {
+        PublishSubject<Integer> ps = PublishSubject.create();
+
+        final int[] calls = { 0 };
+
+        Action1<Integer> a = Actions.empty();
+
+        Subscription s = ps.toSingle().subscribe(a, new Action1<Throwable>() {
+            @Override
+            public void call(Throwable t) {
+                calls[0]++;
+            }
+        });
+
+        assertFalse(s.isUnsubscribed());
+
+        ps.onError(new TestException());
+
+        assertTrue(s.isUnsubscribed());
+
+        assertEquals(1, calls[0]);
+    }
 }

From 1f65cbbceea6d152b8a0f5914eea82eba4686c48 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Wed, 19 Oct 2016 18:10:51 +1100
Subject: [PATCH 183/263] remove AsyncEmitter deprecations (#4725)

---
 src/main/java/rx/AsyncEmitter.java            |  99 ---
 src/main/java/rx/CompletableEmitter.java      |   4 +-
 src/main/java/rx/Observable.java              |  49 --
 .../operators/CompletableFromEmitter.java     |   5 +-
 .../OnSubscribeFromAsyncEmitter.java          | 565 ------------
 .../operators/CompletableFromEmitterTest.java |   8 +-
 .../OnSubscribeFromAsyncEmitterTest.java      | 807 ------------------
 7 files changed, 7 insertions(+), 1530 deletions(-)
 delete mode 100644 src/main/java/rx/AsyncEmitter.java
 delete mode 100644 src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java
 delete mode 100644 src/test/java/rx/internal/operators/OnSubscribeFromAsyncEmitterTest.java

diff --git a/src/main/java/rx/AsyncEmitter.java b/src/main/java/rx/AsyncEmitter.java
deleted file mode 100644
index 0dd132fcdb..0000000000
--- a/src/main/java/rx/AsyncEmitter.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/**
- * Copyright 2016 Netflix, Inc.
- *
- * 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 rx;
-
-import rx.annotations.Experimental;
-
-/**
- * Abstraction over a RxJava Subscriber that allows associating
- * a resource with it and exposes the current number of downstream
- * requested amount.
- * <p>
- * The onNext, onError and onCompleted methods should be called
- * in a sequential manner, just like the Observer's methods. The
- * other methods are thread-safe.
- *
- * @param <T> the value type to emit
- * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
- * @deprecated as of 1.2.1 because Async prefix of this class potentially misleading. Use {@link Emitter} instead.
- */
-@Experimental
-@Deprecated
-public interface AsyncEmitter<T> extends Observer<T> {
-
-    /**
-     * Sets a Subscription on this emitter; any previous Subscription
-     * or Cancellation will be unsubscribed/cancelled.
-     * @param s the subscription, null is allowed
-     */
-    void setSubscription(Subscription s);
-
-    /**
-     * Sets a Cancellable on this emitter; any previous Subscription
-     * or Cancellation will be unsubscribed/cancelled.
-     * @param c the cancellable resource, null is allowed
-     */
-    void setCancellation(Cancellable c);
-    /**
-     * The current outstanding request amount.
-     * <p>This method it thread-safe.
-     * @return the current outstanding request amount
-     */
-    long requested();
-
-    /**
-     * A functional interface that has a single close method
-     * that can throw.
-     */
-    interface Cancellable {
-
-        /**
-         * Cancel the action or free a resource.
-         * @throws Exception on error
-         */
-        void cancel() throws Exception;
-    }
-
-    /**
-     * Options to handle backpressure in the emitter.
-     */
-    enum BackpressureMode {
-        /**
-         * No backpressure is applied an the onNext calls pass through the AsyncEmitter;
-         * note that this may cause {@link rx.exceptions.MissingBackpressureException} or {@link IllegalStateException}
-         * somewhere downstream.
-         */
-        NONE,
-        /**
-         * Signals a {@link rx.exceptions.MissingBackpressureException} if the downstream can't keep up.
-         */
-        ERROR,
-        /**
-         * Buffers (unbounded) all onNext calls until the downstream can consume them.
-         */
-        BUFFER,
-        /**
-         * Drops the incoming onNext value if the downstream can't keep up.
-         */
-        DROP,
-        /**
-         * Keeps the latest onNext value and overwrites it with newer ones until the downstream
-         * can consume it.
-         */
-        LATEST
-    }
-}
diff --git a/src/main/java/rx/CompletableEmitter.java b/src/main/java/rx/CompletableEmitter.java
index 985e567d1d..09f51e0262 100644
--- a/src/main/java/rx/CompletableEmitter.java
+++ b/src/main/java/rx/CompletableEmitter.java
@@ -15,8 +15,8 @@
  */
 package rx;
 
-import rx.AsyncEmitter.Cancellable;
 import rx.annotations.Experimental;
+import rx.functions.Cancellable;
 
 /**
  * Abstraction over a {@link CompletableSubscriber} that gets either an onCompleted or onError
@@ -25,10 +25,8 @@
  * All methods are thread-safe; calling onCompleted or onError twice or one after the other has
  * no effect.
  * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
- * @deprecated as of 1.2.1 because `setCancellation` method will change signature (not name) for 1.2.2.
  */
 @Experimental
-@Deprecated
 public interface CompletableEmitter {
 
     /**
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index a84498ac93..68a176bc9e 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -1976,55 +1976,6 @@ public static <T> Observable<T> from(T[] array) {
         return create(new OnSubscribeFromArray<T>(array));
     }
 
-    /**
-     * Provides an API (via a cold Observable) that bridges the reactive world with the callback-style,
-     * generally non-backpressured world.
-     * <p>
-     * Example:
-     * <pre><code>
-     * Observable.&lt;Event&gt;fromEmitter(emitter -&gt; {
-     *     Callback listener = new Callback() {
-     *         &#64;Override
-     *         public void onEvent(Event e) {
-     *             emitter.onNext(e);
-     *             if (e.isLast()) {
-     *                 emitter.onCompleted();
-     *             }
-     *         }
-     *
-     *         &#64;Override
-     *         public void onFailure(Exception e) {
-     *             emitter.onError(e);
-     *         }
-     *     };
-     *
-     *     AutoCloseable c = api.someMethod(listener);
-     *
-     *     emitter.setCancellation(c::close);
-     *
-     * }, BackpressureMode.BUFFER);
-     * </code></pre>
-     * <p>
-     * You should call the AsyncEmitter's onNext, onError and onCompleted methods in a serialized fashion. The
-     * rest of its methods are thread-safe.
-     *
-     * @param <T> the element type
-     * @param emitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
-     * @param backpressure the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
-     * @return the new Observable instance
-     * @see AsyncEmitter
-     * @see AsyncEmitter.BackpressureMode
-     * @see AsyncEmitter.Cancellable
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
-     * @deprecated since 1.2.1 because Async prefix of AsyncEmitter class is potentially misleading. Use
-     *            {@link #fromEmitter(Action1, Emitter.BackpressureMode)} instead.
-     */
-    @Experimental
-    @Deprecated
-    public static <T> Observable<T> fromEmitter(Action1<AsyncEmitter<T>> emitter, AsyncEmitter.BackpressureMode backpressure) {
-        return create(new OnSubscribeFromAsyncEmitter<T>(emitter, backpressure));
-    }
-
     /**
      * Provides an API (via a cold Observable) that bridges the reactive world with the callback-style,
      * generally non-backpressured world.
diff --git a/src/main/java/rx/internal/operators/CompletableFromEmitter.java b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
index 5bbc02c95d..1b7cea57c2 100644
--- a/src/main/java/rx/internal/operators/CompletableFromEmitter.java
+++ b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
@@ -18,17 +18,16 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.*;
-import rx.AsyncEmitter.Cancellable;
 import rx.exceptions.Exceptions;
 import rx.functions.Action1;
-import rx.internal.operators.OnSubscribeFromAsyncEmitter.CancellableSubscription;
+import rx.functions.Cancellable;
+import rx.internal.operators.OnSubscribeFromEmitter.CancellableSubscription;
 import rx.internal.subscriptions.SequentialSubscription;
 import rx.plugins.RxJavaHooks;
 
 /**
  * Allows push-based emission of terminal events to a CompletableSubscriber.
  */
-@SuppressWarnings("deprecation")
 public final class CompletableFromEmitter implements Completable.OnSubscribe {
 
     final Action1<CompletableEmitter> producer;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java b/src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java
deleted file mode 100644
index 0a10841183..0000000000
--- a/src/main/java/rx/internal/operators/OnSubscribeFromAsyncEmitter.java
+++ /dev/null
@@ -1,565 +0,0 @@
-/**
- * Copyright 2016 Netflix, Inc.
- *
- * 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 rx.internal.operators;
-
-import java.util.Queue;
-import java.util.concurrent.atomic.*;
-
-import rx.*;
-import rx.Observable.OnSubscribe;
-import rx.exceptions.*;
-import rx.functions.Action1;
-import rx.internal.util.RxRingBuffer;
-import rx.internal.util.atomic.SpscUnboundedAtomicArrayQueue;
-import rx.internal.util.unsafe.*;
-import rx.plugins.RxJavaHooks;
-import rx.subscriptions.SerialSubscription;
-
-@Deprecated
-public final class OnSubscribeFromAsyncEmitter<T> implements OnSubscribe<T> {
-
-    final Action1<AsyncEmitter<T>> asyncEmitter;
-
-    final AsyncEmitter.BackpressureMode backpressure;
-
-    public OnSubscribeFromAsyncEmitter(Action1<AsyncEmitter<T>> asyncEmitter, AsyncEmitter.BackpressureMode backpressure) {
-        this.asyncEmitter = asyncEmitter;
-        this.backpressure = backpressure;
-    }
-
-    @Override
-    public void call(Subscriber<? super T> t) {
-        BaseAsyncEmitter<T> emitter;
-
-        switch (backpressure) {
-        case NONE: {
-            emitter = new NoneAsyncEmitter<T>(t);
-            break;
-        }
-        case ERROR: {
-            emitter = new ErrorAsyncEmitter<T>(t);
-            break;
-        }
-        case DROP: {
-            emitter = new DropAsyncEmitter<T>(t);
-            break;
-        }
-        case LATEST: {
-            emitter = new LatestAsyncEmitter<T>(t);
-            break;
-        }
-        default: {
-            emitter = new BufferAsyncEmitter<T>(t, RxRingBuffer.SIZE);
-            break;
-        }
-        }
-
-        t.add(emitter);
-        t.setProducer(emitter);
-        asyncEmitter.call(emitter);
-
-    }
-
-    /**
-     * A Subscription that wraps an AsyncEmitter.Cancellable instance.
-     */
-    static final class CancellableSubscription
-    extends AtomicReference<AsyncEmitter.Cancellable>
-    implements Subscription {
-
-        /** */
-        private static final long serialVersionUID = 5718521705281392066L;
-
-        public CancellableSubscription(AsyncEmitter.Cancellable cancellable) {
-            super(cancellable);
-        }
-
-        @Override
-        public boolean isUnsubscribed() {
-            return get() == null;
-        }
-
-        @Override
-        public void unsubscribe() {
-            if (get() != null) {
-                AsyncEmitter.Cancellable c = getAndSet(null);
-                if (c != null) {
-                    try {
-                        c.cancel();
-                    } catch (Exception ex) {
-                        Exceptions.throwIfFatal(ex);
-                        RxJavaHooks.onError(ex);
-                    }
-                }
-            }
-        }
-    }
-
-    static abstract class BaseAsyncEmitter<T>
-    extends AtomicLong
-    implements AsyncEmitter<T>, Producer, Subscription {
-        /** */
-        private static final long serialVersionUID = 7326289992464377023L;
-
-        final Subscriber<? super T> actual;
-
-        final SerialSubscription serial;
-
-        public BaseAsyncEmitter(Subscriber<? super T> actual) {
-            this.actual = actual;
-            this.serial = new SerialSubscription();
-        }
-
-        @Override
-        public void onCompleted() {
-            if (actual.isUnsubscribed()) {
-                return;
-            }
-            try {
-                actual.onCompleted();
-            } finally {
-                serial.unsubscribe();
-            }
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            if (actual.isUnsubscribed()) {
-                return;
-            }
-            try {
-                actual.onError(e);
-            } finally {
-                serial.unsubscribe();
-            }
-        }
-
-        @Override
-        public final void unsubscribe() {
-            serial.unsubscribe();
-            onUnsubscribed();
-        }
-
-        void onUnsubscribed() {
-            // default is no-op
-        }
-
-        @Override
-        public final boolean isUnsubscribed() {
-            return serial.isUnsubscribed();
-        }
-
-        @Override
-        public final void request(long n) {
-            if (BackpressureUtils.validate(n)) {
-                BackpressureUtils.getAndAddRequest(this, n);
-                onRequested();
-            }
-        }
-
-        void onRequested() {
-            // default is no-op
-        }
-
-        @Override
-        public final void setSubscription(Subscription s) {
-            serial.set(s);
-        }
-
-        @Override
-        public final void setCancellation(AsyncEmitter.Cancellable c) {
-            setSubscription(new CancellableSubscription(c));
-        }
-
-        @Override
-        public final long requested() {
-            return get();
-        }
-    }
-
-    static final class NoneAsyncEmitter<T> extends BaseAsyncEmitter<T> {
-
-        /** */
-        private static final long serialVersionUID = 3776720187248809713L;
-
-        public NoneAsyncEmitter(Subscriber<? super T> actual) {
-            super(actual);
-        }
-
-        @Override
-        public void onNext(T t) {
-            if (actual.isUnsubscribed()) {
-                return;
-            }
-
-            actual.onNext(t);
-
-            for (;;) {
-                long r = get();
-                if (r == 0L || compareAndSet(r, r - 1)) {
-                    return;
-                }
-            }
-        }
-
-    }
-
-    static abstract class NoOverflowBaseAsyncEmitter<T> extends BaseAsyncEmitter<T> {
-
-        /** */
-        private static final long serialVersionUID = 4127754106204442833L;
-
-        public NoOverflowBaseAsyncEmitter(Subscriber<? super T> actual) {
-            super(actual);
-        }
-
-        @Override
-        public void onNext(T t) {
-            if (actual.isUnsubscribed()) {
-                return;
-            }
-
-            if (get() != 0) {
-                actual.onNext(t);
-                BackpressureUtils.produced(this, 1);
-            } else {
-                onOverflow();
-            }
-        }
-
-        abstract void onOverflow();
-    }
-
-    static final class DropAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
-
-        /** */
-        private static final long serialVersionUID = 8360058422307496563L;
-
-        public DropAsyncEmitter(Subscriber<? super T> actual) {
-            super(actual);
-        }
-
-        @Override
-        void onOverflow() {
-            // nothing to do
-        }
-
-    }
-
-    static final class ErrorAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
-
-        /** */
-        private static final long serialVersionUID = 338953216916120960L;
-
-        private boolean done;
-
-        public ErrorAsyncEmitter(Subscriber<? super T> actual) {
-            super(actual);
-        }
-
-
-        @Override
-        public void onNext(T t) {
-            if (done) {
-                return;
-            }
-            super.onNext(t);
-        }
-
-
-        @Override
-        public void onCompleted() {
-            if (done) {
-                return;
-            }
-            done = true;
-            super.onCompleted();
-        }
-
-
-        @Override
-        public void onError(Throwable e) {
-            if (done) {
-                RxJavaHooks.onError(e);
-                return;
-            }
-            done = true;
-            super.onError(e);
-        }
-
-
-        @Override
-        void onOverflow() {
-            onError(new MissingBackpressureException("fromEmitter: could not emit value due to lack of requests"));
-        }
-
-    }
-
-    static final class BufferAsyncEmitter<T> extends BaseAsyncEmitter<T> {
-
-        /** */
-        private static final long serialVersionUID = 2427151001689639875L;
-
-        final Queue<Object> queue;
-
-        Throwable error;
-        volatile boolean done;
-
-        final AtomicInteger wip;
-
-        public BufferAsyncEmitter(Subscriber<? super T> actual, int capacityHint) {
-            super(actual);
-            this.queue = UnsafeAccess.isUnsafeAvailable()
-                    ? new SpscUnboundedArrayQueue<Object>(capacityHint)
-                    : new SpscUnboundedAtomicArrayQueue<Object>(capacityHint);
-            this.wip = new AtomicInteger();
-        }
-
-        @Override
-        public void onNext(T t) {
-            queue.offer(NotificationLite.next(t));
-            drain();
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            error = e;
-            done = true;
-            drain();
-        }
-
-        @Override
-        public void onCompleted() {
-            done = true;
-            drain();
-        }
-
-        @Override
-        void onRequested() {
-            drain();
-        }
-
-        @Override
-        void onUnsubscribed() {
-            if (wip.getAndIncrement() == 0) {
-                queue.clear();
-            }
-        }
-
-        void drain() {
-            if (wip.getAndIncrement() != 0) {
-                return;
-            }
-
-            int missed = 1;
-            final Subscriber<? super T> a = actual;
-            final Queue<Object> q = queue;
-
-            for (;;) {
-                long r = get();
-                long e = 0L;
-
-                while (e != r) {
-                    if (a.isUnsubscribed()) {
-                        q.clear();
-                        return;
-                    }
-
-                    boolean d = done;
-
-                    Object o = q.poll();
-
-                    boolean empty = o == null;
-
-                    if (d && empty) {
-                        Throwable ex = error;
-                        if (ex != null) {
-                            super.onError(ex);
-                        } else {
-                            super.onCompleted();
-                        }
-                        return;
-                    }
-
-                    if (empty) {
-                        break;
-                    }
-
-                    a.onNext(NotificationLite.<T>getValue(o));
-
-                    e++;
-                }
-
-                if (e == r) {
-                    if (a.isUnsubscribed()) {
-                        q.clear();
-                        return;
-                    }
-
-                    boolean d = done;
-
-                    boolean empty = q.isEmpty();
-
-                    if (d && empty) {
-                        Throwable ex = error;
-                        if (ex != null) {
-                            super.onError(ex);
-                        } else {
-                            super.onCompleted();
-                        }
-                        return;
-                    }
-                }
-
-                if (e != 0) {
-                    BackpressureUtils.produced(this, e);
-                }
-
-                missed = wip.addAndGet(-missed);
-                if (missed == 0) {
-                    break;
-                }
-            }
-        }
-    }
-
-    static final class LatestAsyncEmitter<T> extends BaseAsyncEmitter<T> {
-
-        /** */
-        private static final long serialVersionUID = 4023437720691792495L;
-
-        final AtomicReference<Object> queue;
-
-        Throwable error;
-        volatile boolean done;
-
-        final AtomicInteger wip;
-
-        public LatestAsyncEmitter(Subscriber<? super T> actual) {
-            super(actual);
-            this.queue = new AtomicReference<Object>();
-            this.wip = new AtomicInteger();
-        }
-
-        @Override
-        public void onNext(T t) {
-            queue.set(NotificationLite.next(t));
-            drain();
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            error = e;
-            done = true;
-            drain();
-        }
-
-        @Override
-        public void onCompleted() {
-            done = true;
-            drain();
-        }
-
-        @Override
-        void onRequested() {
-            drain();
-        }
-
-        @Override
-        void onUnsubscribed() {
-            if (wip.getAndIncrement() == 0) {
-                queue.lazySet(null);
-            }
-        }
-
-        void drain() {
-            if (wip.getAndIncrement() != 0) {
-                return;
-            }
-
-            int missed = 1;
-            final Subscriber<? super T> a = actual;
-            final AtomicReference<Object> q = queue;
-
-            for (;;) {
-                long r = get();
-                long e = 0L;
-
-                while (e != r) {
-                    if (a.isUnsubscribed()) {
-                        q.lazySet(null);
-                        return;
-                    }
-
-                    boolean d = done;
-
-                    Object o = q.getAndSet(null);
-
-                    boolean empty = o == null;
-
-                    if (d && empty) {
-                        Throwable ex = error;
-                        if (ex != null) {
-                            super.onError(ex);
-                        } else {
-                            super.onCompleted();
-                        }
-                        return;
-                    }
-
-                    if (empty) {
-                        break;
-                    }
-
-                    a.onNext(NotificationLite.<T>getValue(o));
-
-                    e++;
-                }
-
-                if (e == r) {
-                    if (a.isUnsubscribed()) {
-                        q.lazySet(null);
-                        return;
-                    }
-
-                    boolean d = done;
-
-                    boolean empty = q.get() == null;
-
-                    if (d && empty) {
-                        Throwable ex = error;
-                        if (ex != null) {
-                            super.onError(ex);
-                        } else {
-                            super.onCompleted();
-                        }
-                        return;
-                    }
-                }
-
-                if (e != 0) {
-                    BackpressureUtils.produced(this, e);
-                }
-
-                missed = wip.addAndGet(-missed);
-                if (missed == 0) {
-                    break;
-                }
-            }
-        }
-    }
-
-}
diff --git a/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java b/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
index f3a5f3d9a7..a719f186b1 100644
--- a/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
+++ b/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
@@ -150,7 +150,7 @@ public void call(CompletableEmitter e) {
     public void resourceCleanupCancellable() throws Exception {
         TestSubscriber<Void> ts = TestSubscriber.create();
 
-        final AsyncEmitter.Cancellable c = Mockito.mock(AsyncEmitter.Cancellable.class);
+        final Cancellable c = Mockito.mock(Cancellable.class);
 
         Completable.fromEmitter(new Action1<CompletableEmitter>() {
             @Override
@@ -172,7 +172,7 @@ public void resourceCleanupUnsubscirbe() throws Exception {
         TestSubscriber<Void> ts = TestSubscriber.create();
         ts.unsubscribe();
 
-        final AsyncEmitter.Cancellable c = Mockito.mock(AsyncEmitter.Cancellable.class);
+        final Cancellable c = Mockito.mock(Cancellable.class);
 
         Completable.fromEmitter(new Action1<CompletableEmitter>() {
             @Override
@@ -191,7 +191,7 @@ public void call(CompletableEmitter e) {
 
     @Test
     public void resourceCleanupOnCompleteCrashes() throws Exception {
-        final AsyncEmitter.Cancellable c = Mockito.mock(AsyncEmitter.Cancellable.class);
+        final Cancellable c = Mockito.mock(Cancellable.class);
 
         Completable.fromEmitter(new Action1<CompletableEmitter>() {
             @Override
@@ -224,7 +224,7 @@ public void onSubscribe(Subscription d) {
 
     @Test
     public void resourceCleanupOnErrorCrashes() throws Exception {
-        final AsyncEmitter.Cancellable c = Mockito.mock(AsyncEmitter.Cancellable.class);
+        final Cancellable c = Mockito.mock(Cancellable.class);
 
         Completable.fromEmitter(new Action1<CompletableEmitter>() {
             @Override
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromAsyncEmitterTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromAsyncEmitterTest.java
deleted file mode 100644
index 565e3561fe..0000000000
--- a/src/test/java/rx/internal/operators/OnSubscribeFromAsyncEmitterTest.java
+++ /dev/null
@@ -1,807 +0,0 @@
-/**
- * Copyright 2016 Netflix, Inc.
- *
- * 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 rx.internal.operators;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-
-import org.junit.*;
-
-import rx.*;
-import rx.exceptions.*;
-import rx.functions.Action1;
-import rx.observers.TestSubscriber;
-import rx.plugins.RxJavaHooks;
-import rx.subjects.PublishSubject;
-
-/**
- * @deprecated because AsyncEmitter is deprecated (replaced by Emitter).
- */
-@Deprecated
-public class OnSubscribeFromAsyncEmitterTest {
-
-    PublishAsyncEmitter source;
-
-    PublishAsyncEmitterNoCancel sourceNoCancel;
-
-    TestSubscriber<Integer> ts;
-
-    @Before
-    public void before() {
-        source = new PublishAsyncEmitter();
-        sourceNoCancel = new PublishAsyncEmitterNoCancel();
-        ts = TestSubscriber.create(0L);
-    }
-
-    @Test
-    public void normalBuffered() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onCompleted();
-
-        ts.requestMore(1);
-
-        ts.assertValue(1);
-
-        Assert.assertEquals(0, source.requested());
-
-        ts.requestMore(1);
-
-        ts.assertValues(1, 2);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void normalDrop() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
-
-        source.onNext(1);
-
-        ts.requestMore(1);
-
-        source.onNext(2);
-        source.onCompleted();
-
-        ts.assertValues(2);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void normalLatest() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-
-        source.onNext(1);
-
-        source.onNext(2);
-        source.onCompleted();
-
-        ts.requestMore(1);
-
-        ts.assertValues(2);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void normalNone() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onCompleted();
-
-        ts.assertValues(1, 2);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void normalNoneRequested() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
-        ts.requestMore(2);
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onCompleted();
-
-        ts.assertValues(1, 2);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-
-    @Test
-    public void normalError() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onCompleted();
-
-        ts.assertNoValues();
-        ts.assertError(MissingBackpressureException.class);
-        ts.assertNotCompleted();
-
-        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
-    }
-
-    @Test
-    public void overflowErrorIsNotFollowedByAnotherErrorDueToOnNextFromUpstream() {
-        Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
-
-            @Override
-            public void call(AsyncEmitter<Integer> emitter) {
-                emitter.onNext(1);
-                //don't check for unsubscription
-                emitter.onNext(2);
-            }};
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
-
-        ts.assertNoValues();
-        ts.assertError(MissingBackpressureException.class);
-        ts.assertNotCompleted();
-
-        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
-    }
-
-    @Test
-    public void overflowErrorIsNotFollowedByAnotherCompletedDueToCompletedFromUpstream() {
-        Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
-
-            @Override
-            public void call(AsyncEmitter<Integer> emitter) {
-                emitter.onNext(1);
-                //don't check for unsubscription
-                emitter.onCompleted();
-            }};
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
-
-        ts.assertNoValues();
-        ts.assertError(MissingBackpressureException.class);
-        ts.assertNotCompleted();
-
-        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
-    }
-
-    @Test
-    public void overflowErrorIsNotFollowedByAnotherErrorDueToOnErrorFromUpstreamAndSecondErrorIsReportedToHook() {
-        try {
-            final List<Throwable> list = new CopyOnWriteArrayList<Throwable>();
-            RxJavaHooks.setOnError(new Action1<Throwable>() {
-                @Override
-                public void call(Throwable t) {
-                    list.add(t);
-                }});
-            final RuntimeException e = new RuntimeException();
-            Action1<AsyncEmitter<Integer>> source = new Action1<AsyncEmitter<Integer>>(){
-
-                @Override
-                public void call(AsyncEmitter<Integer> emitter) {
-                    emitter.onNext(1);
-                    //don't check for unsubscription
-                    emitter.onError(e);
-                }};
-            Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
-
-            ts.assertNoValues();
-            ts.assertError(MissingBackpressureException.class);
-            ts.assertNotCompleted();
-
-            Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
-            assertEquals(Arrays.asList(e), list);
-        } finally {
-            RxJavaHooks.reset();
-        }
-    }
-
-    @Test
-    public void errorBuffered() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertValue(1);
-
-        ts.requestMore(1);
-
-        ts.assertValues(1, 2);
-        ts.assertError(TestException.class);
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void errorLatest() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertValues(2);
-        ts.assertError(TestException.class);
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void errorNone() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertValues(1, 2);
-        ts.assertError(TestException.class);
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribedBuffer() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-        ts.unsubscribe();
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertNoValues();
-        ts.assertNoErrors();
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribedLatest() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-        ts.unsubscribe();
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertNoValues();
-        ts.assertNoErrors();
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribedError() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
-        ts.unsubscribe();
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertNoValues();
-        ts.assertNoErrors();
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribedDrop() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
-        ts.unsubscribe();
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertNoValues();
-        ts.assertNoErrors();
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribedNone() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
-        ts.unsubscribe();
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertNoValues();
-        ts.assertNoErrors();
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribedNoCancelBuffer() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-        ts.unsubscribe();
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onNext(2);
-        sourceNoCancel.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertNoValues();
-        ts.assertNoErrors();
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribedNoCancelLatest() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-        ts.unsubscribe();
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onNext(2);
-        sourceNoCancel.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertNoValues();
-        ts.assertNoErrors();
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribedNoCancelError() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.ERROR).subscribe(ts);
-        ts.unsubscribe();
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onNext(2);
-        sourceNoCancel.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertNoValues();
-        ts.assertNoErrors();
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribedNoCancelDrop() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.DROP).subscribe(ts);
-        ts.unsubscribe();
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onNext(2);
-        sourceNoCancel.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertNoValues();
-        ts.assertNoErrors();
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribedNoCancelNone() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.NONE).subscribe(ts);
-        ts.unsubscribe();
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onNext(2);
-        sourceNoCancel.onError(new TestException());
-
-        ts.requestMore(1);
-
-        ts.assertNoValues();
-        ts.assertNoErrors();
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void deferredRequest() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onCompleted();
-
-        ts.requestMore(2);
-
-        ts.assertValues(1, 2);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void take() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onCompleted();
-
-        ts.requestMore(2);
-
-        ts.assertValues(1, 2);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void takeOne() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
-        ts.requestMore(2);
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onCompleted();
-
-        ts.assertValues(1);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void requestExact() {
-        Observable.fromEmitter(source, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-        ts.requestMore(2);
-
-        source.onNext(1);
-        source.onNext(2);
-        source.onCompleted();
-
-        ts.assertValues(1, 2);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void takeNoCancel() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onNext(2);
-        sourceNoCancel.onCompleted();
-
-        ts.requestMore(2);
-
-        ts.assertValues(1, 2);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void takeOneNoCancel() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
-        ts.requestMore(2);
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onNext(2);
-        sourceNoCancel.onCompleted();
-
-        ts.assertValues(1);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void unsubscribeNoCancel() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-        ts.requestMore(2);
-
-        sourceNoCancel.onNext(1);
-
-        ts.unsubscribe();
-
-        sourceNoCancel.onNext(2);
-
-        ts.assertValues(1);
-        ts.assertNoErrors();
-        ts.assertNotCompleted();
-    }
-
-
-    @Test
-    public void unsubscribeInline() {
-        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>() {
-            @Override
-            public void onNext(Integer t) {
-                super.onNext(t);
-                unsubscribe();
-            }
-        };
-
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
-
-        sourceNoCancel.onNext(1);
-
-        ts1.assertValues(1);
-        ts1.assertNoErrors();
-        ts1.assertNotCompleted();
-    }
-
-    @Test
-    public void completeInline() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onCompleted();
-
-        ts.requestMore(2);
-
-        ts.assertValues(1);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void errorInline() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts);
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onError(new TestException());
-
-        ts.requestMore(2);
-
-        ts.assertValues(1);
-        ts.assertError(TestException.class);
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void requestInline() {
-        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1) {
-            @Override
-            public void onNext(Integer t) {
-                super.onNext(t);
-                requestMore(1);
-            }
-        };
-
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.BUFFER).subscribe(ts1);
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onNext(2);
-
-        ts1.assertValues(1, 2);
-        ts1.assertNoErrors();
-        ts1.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribeInlineLatest() {
-        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>() {
-            @Override
-            public void onNext(Integer t) {
-                super.onNext(t);
-                unsubscribe();
-            }
-        };
-
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
-
-        sourceNoCancel.onNext(1);
-
-        ts1.assertValues(1);
-        ts1.assertNoErrors();
-        ts1.assertNotCompleted();
-    }
-
-    @Test
-    public void unsubscribeInlineExactLatest() {
-        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1L) {
-            @Override
-            public void onNext(Integer t) {
-                super.onNext(t);
-                unsubscribe();
-            }
-        };
-
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
-
-        sourceNoCancel.onNext(1);
-
-        ts1.assertValues(1);
-        ts1.assertNoErrors();
-        ts1.assertNotCompleted();
-    }
-
-    @Test
-    public void completeInlineLatest() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onCompleted();
-
-        ts.requestMore(2);
-
-        ts.assertValues(1);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void completeInlineExactLatest() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onCompleted();
-
-        ts.requestMore(1);
-
-        ts.assertValues(1);
-        ts.assertNoErrors();
-        ts.assertCompleted();
-    }
-
-    @Test
-    public void errorInlineLatest() {
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts);
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onError(new TestException());
-
-        ts.requestMore(2);
-
-        ts.assertValues(1);
-        ts.assertError(TestException.class);
-        ts.assertNotCompleted();
-    }
-
-    @Test
-    public void requestInlineLatest() {
-        TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1) {
-            @Override
-            public void onNext(Integer t) {
-                super.onNext(t);
-                requestMore(1);
-            }
-        };
-
-        Observable.fromEmitter(sourceNoCancel, AsyncEmitter.BackpressureMode.LATEST).subscribe(ts1);
-
-        sourceNoCancel.onNext(1);
-        sourceNoCancel.onNext(2);
-
-        ts1.assertValues(1, 2);
-        ts1.assertNoErrors();
-        ts1.assertNotCompleted();
-    }
-
-    static final class PublishAsyncEmitter implements Action1<AsyncEmitter<Integer>>, Observer<Integer> {
-
-        final PublishSubject<Integer> subject;
-
-        AsyncEmitter<Integer> current;
-
-        public PublishAsyncEmitter() {
-            this.subject = PublishSubject.create();
-        }
-
-        long requested() {
-            return current.requested();
-        }
-
-        @Override
-        public void call(final AsyncEmitter<Integer> t) {
-
-            this.current = t;
-
-            final Subscription s = subject.subscribe(new Observer<Integer>() {
-
-                @Override
-                public void onCompleted() {
-                    t.onCompleted();
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    t.onError(e);
-                }
-
-                @Override
-                public void onNext(Integer v) {
-                    t.onNext(v);
-                }
-
-            });
-
-            t.setCancellation(new AsyncEmitter.Cancellable() {
-                @Override
-                public void cancel() throws Exception {
-                    s.unsubscribe();
-                }
-            });;
-        }
-
-        @Override
-        public void onNext(Integer t) {
-            subject.onNext(t);
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            subject.onError(e);
-        }
-
-        @Override
-        public void onCompleted() {
-            subject.onCompleted();
-        }
-    }
-
-    static final class PublishAsyncEmitterNoCancel implements Action1<AsyncEmitter<Integer>>, Observer<Integer> {
-
-        final PublishSubject<Integer> subject;
-
-        public PublishAsyncEmitterNoCancel() {
-            this.subject = PublishSubject.create();
-        }
-
-        @Override
-        public void call(final AsyncEmitter<Integer> t) {
-
-            subject.subscribe(new Observer<Integer>() {
-
-                @Override
-                public void onCompleted() {
-                    t.onCompleted();
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    t.onError(e);
-                }
-
-                @Override
-                public void onNext(Integer v) {
-                    t.onNext(v);
-                }
-
-            });
-        }
-
-        @Override
-        public void onNext(Integer t) {
-            subject.onNext(t);
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            subject.onError(e);
-        }
-
-        @Override
-        public void onCompleted() {
-            subject.onCompleted();
-        }
-    }
-
-}

From 61a5976e3dacbbf0e6a4bbfbaf3a11cc3d335b70 Mon Sep 17 00:00:00 2001
From: Jake Wharton <jakewharton@gmail.com>
Date: Fri, 21 Oct 2016 13:41:38 -0400
Subject: [PATCH 184/263] Remove unused helper class previously used by
 extend(). (#4745)

---
 src/main/java/rx/Observable.java | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 68a176bc9e..605f51dd27 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -201,22 +201,6 @@ public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<
         // cover for generics insanity
     }
 
-    /**
-     * Transforms a OnSubscribe.call() into an Observable.subscribe() call.
-     * <p>Note: has to be in Observable because it calls the package-private subscribe() method
-     * @param <T> the value type
-     */
-    static final class OnSubscribeExtend<T> implements OnSubscribe<T> {
-        final Observable<T> parent;
-        OnSubscribeExtend(Observable<T> parent) {
-            this.parent = parent;
-        }
-        @Override
-        public void call(Subscriber<? super T> subscriber) {
-            subscriber.add(subscribe(subscriber, parent));
-        }
-    }
-
     /**
      * <strong>This method requires advanced knowledge about building operators; please consider
      * other standard composition methods first;</strong>

From 5e3f6c4141f0e2b10765270d0faf83de014ec804 Mon Sep 17 00:00:00 2001
From: Pierre-Yves Ricau <py.ricau@gmail.com>
Date: Sat, 22 Oct 2016 10:58:53 -0700
Subject: [PATCH 185/263] #4737 Error when tracking exception with unknown
 cause (#4740)

---
 .../AssemblyStackTraceException.java          | 10 ++++-
 src/test/java/rx/plugins/RxJavaHooksTest.java | 42 +++++++++++++++++++
 2 files changed, 51 insertions(+), 1 deletion(-)

diff --git a/src/main/java/rx/exceptions/AssemblyStackTraceException.java b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
index 5fee891344..8342adc637 100644
--- a/src/main/java/rx/exceptions/AssemblyStackTraceException.java
+++ b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
@@ -52,7 +52,15 @@ public void attachTo(Throwable exception) {
 
         for (;;) {
             if (exception.getCause() == null) {
-                exception.initCause(this);
+                try {
+                    exception.initCause(this);
+                } catch (IllegalStateException e) {
+                    RxJavaHooks.onError(new RuntimeException(
+                        "Received an exception with a cause set to null, instead of being unset."
+                            + " To fix this, look down the chain of causes. The last exception had"
+                            + " a cause explicitly set to null. It should be unset instead.",
+                        exception));
+                }
                 return;
             }
 
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index 3d9bdb7872..89a118482d 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -23,8 +23,10 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import java.util.concurrent.atomic.AtomicReference;
 import org.junit.Test;
 
+import org.mockito.Mockito;
 import rx.*;
 import rx.Observable;
 import rx.Scheduler.Worker;
@@ -39,6 +41,12 @@
 
 public class RxJavaHooksTest {
 
+    public static class TestExceptionWithUnknownCause extends RuntimeException {
+        TestExceptionWithUnknownCause() {
+            super((Throwable) null);
+        }
+    }
+
     static Observable<Integer> createObservable() {
         return Observable.range(1, 5).map(new Func1<Integer, Integer>() {
             @Override
@@ -48,6 +56,15 @@ public Integer call(Integer t) {
         });
     }
 
+    static Observable<Integer> createObservableThrowingUnknownCause() {
+        return Observable.range(1, 5).map(new Func1<Integer, Integer>() {
+            @Override
+            public Integer call(Integer t) {
+                throw new TestExceptionWithUnknownCause();
+            }
+        });
+    }
+
     @Test
     public void constructorShouldBePrivate() {
         TestUtil.checkUtilityClass(RxJavaHooks.class);
@@ -89,6 +106,31 @@ public void assemblyTrackingObservable() {
         }
     }
 
+    @Test
+    public void assemblyTrackingObservableUnknownCause() {
+        RxJavaHooks.enableAssemblyTracking();
+        try {
+            final AtomicReference<Throwable> onErrorThrowableRef = new AtomicReference<Throwable>();
+            RxJavaHooks.setOnError(new Action1<Throwable>() {
+                @Override
+                public void call(Throwable throwable) {
+                    onErrorThrowableRef.set(throwable);
+                }
+            });
+            TestSubscriber<Integer> ts = TestSubscriber.create();
+
+            createObservableThrowingUnknownCause().subscribe(ts);
+
+            ts.assertError(TestExceptionWithUnknownCause.class);
+
+            Throwable receivedError = onErrorThrowableRef.get();
+            assertNotNull(receivedError);
+            assertTrue(receivedError.getMessage().contains("cause set to null"));
+        } finally {
+            RxJavaHooks.reset();
+        }
+    }
+
     static Single<Integer> createSingle() {
         return Single.just(1).map(new Func1<Integer, Integer>() {
             @Override

From 850deea48e68d3eb970e7b10f3a13858244ecf32 Mon Sep 17 00:00:00 2001
From: Erick C <ekchang@users.noreply.github.com>
Date: Mon, 24 Oct 2016 18:14:58 -0400
Subject: [PATCH 186/263] 1.x: Add cache() to Single (#4757)

* Add cache to Single

* Add Experimental annotation

* Update javadoc
---
 src/main/java/rx/Single.java     | 57 ++++++++++++++++++++++++++++++++
 src/test/java/rx/SingleTest.java | 47 ++++++++++++++++++++++++++
 2 files changed, 104 insertions(+)

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 5ee58d8f8d..b0ac837610 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -21,6 +21,7 @@
 import rx.functions.*;
 import rx.internal.operators.*;
 import rx.internal.util.*;
+import rx.observables.ConnectableObservable;
 import rx.observers.*;
 import rx.plugins.RxJavaHooks;
 import rx.schedulers.Schedulers;
@@ -1269,6 +1270,62 @@ public static <R> Single<R> zip(Iterable<? extends Single<?>> singles, FuncN<? e
         return SingleOperatorZip.zip(iterableToArray, zipFunction);
     }
 
+    /**
+     * Returns a Single that subscribes to this Single lazily, caches its success or error event
+     * and replays it to all the downstream subscribers.
+     * <p>
+     * <img width="640" height="410" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/cache.png" alt="">
+     * <p>
+     * This is useful when you want a Single to cache its response and you can't control the
+     * subscribe/unsubscribe behavior of all the {@link Subscriber}s.
+     * <p>
+     * The operator subscribes only when the first downstream subscriber subscribes and maintains
+     * a single subscription towards this Single. In contrast, the operator family of {@link Observable#replay()}
+     * that return a {@link ConnectableObservable} require an explicit call to {@link ConnectableObservable#connect()}.
+     * <p>
+     * <em>Note:</em> You sacrifice the ability to unsubscribe from the origin when you use the {@code cache}
+     * Observer so be careful not to use this Observer on Observables that emit an infinite or very large number
+     * of items that will use up memory.
+     * A possible workaround is to apply `takeUntil` with a predicate or
+     * another source before (and perhaps after) the application of cache().
+     * <pre><code>
+     * AtomicBoolean shouldStop = new AtomicBoolean();
+     *
+     * source.takeUntil(v -&gt; shouldStop.get())
+     *       .cache()
+     *       .takeUntil(v -&gt; shouldStop.get())
+     *       .subscribe(...);
+     * </code></pre>
+     * Since the operator doesn't allow clearing the cached values either, the possible workaround is
+     * to forget all references to it via {@link Observable#onTerminateDetach()} applied along with the previous
+     * workaround:
+     * <pre><code>
+     * AtomicBoolean shouldStop = new AtomicBoolean();
+     *
+     * source.takeUntil(v -&gt; shouldStop.get())
+     *       .onTerminateDetach()
+     *       .cache()
+     *       .takeUntil(v -&gt; shouldStop.get())
+     *       .onTerminateDetach()
+     *       .subscribe(...);
+     * </code></pre>
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes this Single in an unbounded fashion but respects the backpressure
+     *  of each downstream Subscriber individually.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code cache} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @return a Single that, when first subscribed to, caches its response for the
+     *         benefit of subsequent subscribers
+     * @see <a href="http://reactivex.io/documentation/operators/replay.html">ReactiveX operators documentation: Replay</a>
+     */
+    @Experimental
+    public final Single<T> cache() {
+        return toObservable().cacheWithInitialCapacity(1).toSingle();
+    }
+
     /**
      * Returns an Observable that emits the item emitted by the source Single, then the item emitted by the
      * specified Single.
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index ef8bd0995e..41b75e73f7 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -503,6 +503,53 @@ public void testReturnUnsubscribedWhenHookThrowsError() {
         assertTrue(subscription.isUnsubscribed());
     }
 
+    @Test
+    public void testCache() throws InterruptedException {
+        final AtomicInteger counter = new AtomicInteger();
+        Single<String> s = Single.create(new OnSubscribe<String>() {
+
+            @Override
+            public void call(final SingleSubscriber<? super String> observer) {
+                new Thread(new Runnable() {
+
+                    @Override
+                    public void run() {
+                        counter.incrementAndGet();
+                        observer.onSuccess("one");
+                    }
+                }).start();
+            }
+        }).cache();
+
+        // we then expect the following 2 subscriptions to get that same value
+        final CountDownLatch latch = new CountDownLatch(2);
+
+        // subscribe once
+        s.subscribe(new Action1<String>() {
+
+            @Override
+            public void call(String v) {
+                assertEquals("one", v);
+                latch.countDown();
+            }
+        });
+
+        // subscribe again
+        s.subscribe(new Action1<String>() {
+
+            @Override
+            public void call(String v) {
+                assertEquals("one", v);
+                latch.countDown();
+            }
+        });
+
+        if (!latch.await(1000, TimeUnit.MILLISECONDS)) {
+            fail("subscriptions did not receive values");
+        }
+        assertEquals(1, counter.get());
+    }
+
     @Test
     public void testCreateSuccess() {
         TestSubscriber<String> ts = new TestSubscriber<String>();

From 039a703be5c0bd0c06e21f7c37ab2e1262bb1023 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Tue, 25 Oct 2016 18:51:47 +1100
Subject: [PATCH 187/263] zip - check local boolean before volatile in boolean
 and (#4764)

---
 src/main/java/rx/internal/operators/OperatorZip.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/rx/internal/operators/OperatorZip.java b/src/main/java/rx/internal/operators/OperatorZip.java
index 235996c6e3..a8e2cca2f0 100644
--- a/src/main/java/rx/internal/operators/OperatorZip.java
+++ b/src/main/java/rx/internal/operators/OperatorZip.java
@@ -246,7 +246,7 @@ void tick() {
                             }
                         }
                         // we only emit if requested > 0 and have all values available
-                        if (requested.get() > 0 && allHaveValues) {
+                        if (allHaveValues && requested.get() > 0) {
                             try {
                                 // all have something so emit
                                 child.onNext(zipFunction.call(vs));

From 57470176b1f1d68904544fce92de3f52ea645300 Mon Sep 17 00:00:00 2001
From: Alexey Agapitov <marwinxxii@users.noreply.github.com>
Date: Wed, 26 Oct 2016 19:43:54 +0400
Subject: [PATCH 188/263] Add note to SingleSubscriber doc about unsubscribe
 invocation in onSuccess and onError. (#4769)

---
 src/main/java/rx/SingleSubscriber.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/main/java/rx/SingleSubscriber.java b/src/main/java/rx/SingleSubscriber.java
index 05270748ad..53e9a70faa 100644
--- a/src/main/java/rx/SingleSubscriber.java
+++ b/src/main/java/rx/SingleSubscriber.java
@@ -24,6 +24,9 @@
  * {@code Single} calls the SingleSubscriber's {@link #onSuccess} and {@link #onError} methods to provide
  * notifications. A well-behaved {@code Single} will call a SingleSubscriber's {@link #onSuccess} method exactly
  * once or the SingleSubscriber's {@link #onError} method exactly once.
+ * <p>
+ * Note, that if you want {@link #isUnsubscribed} to return {@code true} after {@link #onSuccess} or {@link #onError}
+ * invocation, you need to invoke {@link #unsubscribe} in these methods.
  *
  * @see <a href="http://reactivex.io/documentation/observable.html">ReactiveX documentation: Observable</a>
  * @param <T>

From c65b3db77f56001e5f160b699e3cad9737df1e31 Mon Sep 17 00:00:00 2001
From: Andrew Bushmin <diskbu@yandex.ru>
Date: Tue, 1 Nov 2016 17:32:04 +0300
Subject: [PATCH 189/263] 1.x: Add null check to Observable.switchIfEmpty
 (#4791)

* Add null check to switchIfEmpty (#4762)

* Add null check to switchIfEmpty (#4762); add test
---
 src/main/java/rx/Observable.java                             | 5 +++++
 .../rx/internal/operators/OperatorSwitchIfEmptyTest.java     | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 605f51dd27..dd67541c2f 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -5403,9 +5403,14 @@ public final Observable<T> defaultIfEmpty(final T defaultValue) {
      *              the alternate Observable to subscribe to if the source does not emit any items
      * @return  an Observable that emits the items emitted by the source Observable or the items of an
      *          alternate Observable if the source Observable is empty.
+     * @throws NullPointerException
+     *              if {@code alternate} is null
      * @since 1.1.0
      */
     public final Observable<T> switchIfEmpty(Observable<? extends T> alternate) {
+        if (alternate == null) {
+            throw new NullPointerException("alternate is null");
+        }
         return lift(new OperatorSwitchIfEmpty<T>(alternate));
     }
 
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java b/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
index 12a9b72e5e..70225a53eb 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
@@ -207,4 +207,9 @@ public void call() {
         ts.assertValueCount(2);
         ts.unsubscribe();
     }
+
+    @Test(expected = NullPointerException.class)
+    public void testAlternateNull() {
+        Observable.just(1).switchIfEmpty(null);
+    }
 }
\ No newline at end of file

From 63850510fd51df5de398f47322852b0946ec30c2 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Thu, 3 Nov 2016 10:04:55 +0100
Subject: [PATCH 190/263] Release 1.2.2

---
 CHANGES.md                                    | 42 +++++++++++++++++++
 src/main/java/rx/Completable.java             |  1 -
 .../operators/CompletableFromEmitterTest.java |  1 -
 src/test/java/rx/plugins/RxJavaHooksTest.java |  6 +--
 4 files changed, 45 insertions(+), 5 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 17ba6a9a89..1741085701 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,47 @@
 # RxJava Releases #
 
+### Version 1.2.2 - November 3, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.2%7C))
+
+Note that the interface `Cancellable` has been moved to `rx.functions` affecting `CompletableEmitter` and  the experimental `Observable.fromEmitter(Action1<AsyncEmitter<T>> emitter, AsyncEmitter.BackpressureMode backpressure)` has been removed.
+
+Another important clarification was added to the javadoc about using `SingleSubscriber`: due to the internal enhancements of `Single`, a `SingleSubscriber` is no longer wrapped into a `Subscriber`+`SafeSubscriber` which setup used to call `unsubscribe` on the `SingleSubscriber` yielding `isUnsubscribed() == true` when the source terminated. Therefore, when one extends the class `SingleSubscriber`, the `unsubscribe()` should be called manually to yield the given expecation mentioned before:
+
+``` java
+Subscritpion s = Single.just(1).subscribe(new SingleSubscriber<Integer>() {
+    @Override public void onSuccess(Integer t) {
+        System.out.println("Success");
+        unsubscribe();
+    }
+
+    @Override public void onError(Throwable e) {
+        e.printStackTrace();
+        unsubscribe();
+    }
+});
+
+assertTrue(s.isUnsubscribed());
+```
+#### Documentation enhancements
+
+- [Pull 4693](https://github.com/ReactiveX/RxJava/pull/4693): improve `timer` javadoc
+- [Pull 4769](https://github.com/ReactiveX/RxJava/pull/4769): Add note to `SingleSubscriber` doc about unsubscribe invocation in `onSuccess` and `onError`.
+
+#### API enhancements
+
+- [Pull 4725](https://github.com/ReactiveX/RxJava/pull/4725): remove `AsyncEmitter` deprecations
+- [Pull 4757](https://github.com/ReactiveX/RxJava/pull/4757): Add `cache()` to `Single`
+
+#### Performance enhancements
+
+- [Pull 4676](https://github.com/ReactiveX/RxJava/pull/4676): Make identity function a singleton.
+- [Pull 4764](https://github.com/ReactiveX/RxJava/pull/4764): `zip` - check local boolean before volatile in boolean and
+
+#### Bugfixes
+
+- [Pull 4716](https://github.com/ReactiveX/RxJava/pull/4716): fix`subscribe(Action1 [, Action1])` to report `isUnsubscribed` true after the callbacks were invoked
+- [Pull 4740](https://github.com/ReactiveX/RxJava/pull/4740): Error when tracking exception with unknown cause
+- [Pull 4791](https://github.com/ReactiveX/RxJava/pull/4791): Add null check to `Observable.switchIfEmpty`
+
 ### Version 1.2.1 - October 5, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.1%7C))
 
 #### API enhancements
diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index e9ae55239a..e604fdaf71 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -540,7 +540,6 @@ public void call(rx.CompletableSubscriber s) {
      * @return the new Completable instance
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
      */
-    @SuppressWarnings("deprecation")
     @Experimental
     public static Completable fromEmitter(Action1<CompletableEmitter> producer) {
         return create(new CompletableFromEmitter(producer));
diff --git a/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java b/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
index a719f186b1..32107591fc 100644
--- a/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
+++ b/src/test/java/rx/internal/operators/CompletableFromEmitterTest.java
@@ -29,7 +29,6 @@
 import rx.observers.TestSubscriber;
 import rx.subscriptions.BooleanSubscription;
 
-@SuppressWarnings("deprecation")
 public class CompletableFromEmitterTest {
 
     @Test
diff --git a/src/test/java/rx/plugins/RxJavaHooksTest.java b/src/test/java/rx/plugins/RxJavaHooksTest.java
index 89a118482d..a4b3999f73 100644
--- a/src/test/java/rx/plugins/RxJavaHooksTest.java
+++ b/src/test/java/rx/plugins/RxJavaHooksTest.java
@@ -21,12 +21,10 @@
 import java.lang.reflect.Method;
 import java.util.*;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.*;
 
-import java.util.concurrent.atomic.AtomicReference;
 import org.junit.Test;
 
-import org.mockito.Mockito;
 import rx.*;
 import rx.Observable;
 import rx.Scheduler.Worker;
@@ -42,6 +40,8 @@
 public class RxJavaHooksTest {
 
     public static class TestExceptionWithUnknownCause extends RuntimeException {
+        private static final long serialVersionUID = 6771158999860253299L;
+
         TestExceptionWithUnknownCause() {
             super((Throwable) null);
         }

From d6bc9237338f26853a99149751342f54e5ba9b18 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Wed, 9 Nov 2016 20:33:53 +1100
Subject: [PATCH 191/263] add TestSubscriber2 to provide method chained version
 of TestSubscriber and support Observable.test() (#4777)

---
 src/main/java/rx/Completable.java             |  23 ++
 src/main/java/rx/Observable.java              |  43 +++
 src/main/java/rx/Single.java                  |  23 ++
 .../AssertableSubscriberObservable.java       | 310 ++++++++++++++++++
 .../rx/observers/AssertableSubscriber.java    |  87 +++++
 .../observers/AssertableSubscriberTest.java   | 162 +++++++++
 6 files changed, 648 insertions(+)
 create mode 100644 src/main/java/rx/internal/observers/AssertableSubscriberObservable.java
 create mode 100644 src/main/java/rx/observers/AssertableSubscriber.java
 create mode 100644 src/test/java/rx/observers/AssertableSubscriberTest.java

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index e604fdaf71..12d088c35d 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -23,6 +23,7 @@
 import rx.annotations.*;
 import rx.exceptions.*;
 import rx.functions.*;
+import rx.internal.observers.AssertableSubscriberObservable;
 import rx.internal.operators.*;
 import rx.internal.util.*;
 import rx.observers.*;
@@ -2364,4 +2365,26 @@ public void call() {
             }
         });
     }
+    
+    // -------------------------------------------------------------------------
+    // Fluent test support, super handy and reduces test preparation boilerplate
+    // -------------------------------------------------------------------------
+    /**
+     * Creates an AssertableSubscriber that requests {@code Long.MAX_VALUE} and subscribes
+     * it to this Observable.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The returned AssertableSubscriber consumes this Observable in an unbounded fashion.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code test} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @return the new AssertableSubscriber instance
+     * @since 1.2.3
+     */
+    @Experimental
+    public final AssertableSubscriber<Void> test() {
+        AssertableSubscriberObservable<Void> ts = AssertableSubscriberObservable.create(Long.MAX_VALUE);
+        subscribe(ts);
+        return ts;
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index dd67541c2f..904ccec45c 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -18,10 +18,12 @@
 import rx.annotations.*;
 import rx.exceptions.*;
 import rx.functions.*;
+import rx.internal.observers.AssertableSubscriberObservable;
 import rx.internal.operators.*;
 import rx.internal.util.*;
 import rx.observables.*;
 import rx.observers.SafeSubscriber;
+import rx.observers.AssertableSubscriber;
 import rx.plugins.*;
 import rx.schedulers.*;
 import rx.subscriptions.Subscriptions;
@@ -12640,4 +12642,45 @@ public final <T2, R> Observable<R> zipWith(Iterable<? extends T2> other, Func2<?
     public final <T2, R> Observable<R> zipWith(Observable<? extends T2> other, Func2<? super T, ? super T2, ? extends R> zipFunction) {
         return (Observable<R>)zip(this, other, zipFunction);
     }
+    
+    // -------------------------------------------------------------------------
+    // Fluent test support, super handy and reduces test preparation boilerplate
+    // -------------------------------------------------------------------------
+    /**
+     * Creates a AssertableSubscriber that requests {@code Long.MAX_VALUE} and subscribes
+     * it to this Observable.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The returned AssertableSubscriber consumes this Observable in an unbounded fashion.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code test} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @return the new AssertableSubscriber instance
+     * @since 1.2.3
+     */
+    @Experimental
+    public final AssertableSubscriber<T> test() {
+        AssertableSubscriber<T> ts = AssertableSubscriberObservable.create(Long.MAX_VALUE);
+        subscribe(ts);
+        return ts;
+    }
+    
+    /**
+     * Creates an AssertableSubscriber with the initial request amount and subscribes
+     * it to this Observable.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The returned AssertableSubscriber requests the given {@code initialRequest} amount upfront.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code test} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @return the new AssertableSubscriber instance
+     * @since 1.2.3
+     */
+    @Experimental
+    public final AssertableSubscriber<T> test(long initialRequestAmount) {
+        AssertableSubscriber<T> ts = AssertableSubscriberObservable.create(initialRequestAmount);
+        subscribe(ts);
+        return ts;
+    }
 }
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index b0ac837610..7b85c4d3a5 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -19,6 +19,7 @@
 import rx.annotations.*;
 import rx.exceptions.*;
 import rx.functions.*;
+import rx.internal.observers.AssertableSubscriberObservable;
 import rx.internal.operators.*;
 import rx.internal.util.*;
 import rx.observables.ConnectableObservable;
@@ -2675,4 +2676,26 @@ public final Single<T> delaySubscription(Observable<?> other) {
         }
         return create(new SingleOnSubscribeDelaySubscriptionOther<T>(this, other));
     }
+
+    // -------------------------------------------------------------------------
+    // Fluent test support, super handy and reduces test preparation boilerplate
+    // -------------------------------------------------------------------------
+    /**
+     * Creates an AssertableSubscriber that requests {@code Long.MAX_VALUE} and subscribes
+     * it to this Observable.
+     * <dl>
+     *  <dt><b>Backpressure:</b><dt>
+     *  <dd>The returned AssertableSubscriber consumes this Observable in an unbounded fashion.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code test} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @return the new AssertableSubscriber instance
+     * @since 1.2.3
+     */
+    @Experimental
+    public final AssertableSubscriber<T> test() {
+        AssertableSubscriberObservable<T> ts = AssertableSubscriberObservable.create(Long.MAX_VALUE);
+        subscribe(ts);
+        return ts;
+    }
 }
diff --git a/src/main/java/rx/internal/observers/AssertableSubscriberObservable.java b/src/main/java/rx/internal/observers/AssertableSubscriberObservable.java
new file mode 100644
index 0000000000..db1c4f0532
--- /dev/null
+++ b/src/main/java/rx/internal/observers/AssertableSubscriberObservable.java
@@ -0,0 +1,310 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.observers;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import rx.Producer;
+import rx.Subscriber;
+import rx.annotations.Experimental;
+import rx.functions.Action0;
+import rx.observers.TestSubscriber;
+import rx.observers.AssertableSubscriber;
+
+/**
+ * A {@code AssertableSubscriber} is a variety of {@link Subscriber} that you can use
+ * for unit testing, to perform assertions or inspect received events.
+ * AssertableSubscriber is a duplicate of TestSubscriber but supports method chaining
+ * where possible.
+ * 
+ * @param <T>
+ *            the value type
+ */
+@Experimental
+public class AssertableSubscriberObservable<T> extends Subscriber<T> implements AssertableSubscriber<T> {
+
+    private final TestSubscriber<T> ts;
+
+    public AssertableSubscriberObservable(TestSubscriber<T> ts) {
+        this.ts = ts;
+    }
+
+    public static <T> AssertableSubscriberObservable<T> create(long initialRequest) {
+        TestSubscriber<T> t1 = new TestSubscriber<T>(initialRequest);
+        AssertableSubscriberObservable<T> t2 = new AssertableSubscriberObservable<T>(t1);
+        t2.add(t1);
+        return t2;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#onStart()
+     */
+    @Override
+    public void onStart() {
+        ts.onStart();
+    }
+
+    @Override
+    public void onCompleted() {
+        ts.onCompleted();
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#setProducer(rx.Producer)
+     */
+    @Override
+    public void setProducer(Producer p) {
+        ts.setProducer(p);
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#getCompletions()
+     */
+    @Override
+    public final int getCompletions() {
+        return ts.getCompletions();
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        ts.onError(e);
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#getOnErrorEvents()
+     */
+    @Override
+    public List<Throwable> getOnErrorEvents() {
+        return ts.getOnErrorEvents();
+    }
+
+    @Override
+    public void onNext(T t) {
+        ts.onNext(t);
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#getValueCount()
+     */
+    @Override
+    public final int getValueCount() {
+        return ts.getValueCount();
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#requestMore(long)
+     */
+    @Override
+    public AssertableSubscriber<T> requestMore(long n) {
+        ts.requestMore(n);
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#getOnNextEvents()
+     */
+    @Override
+    public List<T> getOnNextEvents() {
+        return ts.getOnNextEvents();
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertReceivedOnNext(java.util.List)
+     */
+    @Override
+    public AssertableSubscriber<T> assertReceivedOnNext(List<T> items) {
+        ts.assertReceivedOnNext(items);
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#awaitValueCount(int, long, java.util.concurrent.TimeUnit)
+     */
+    @Override
+    public final boolean awaitValueCount(int expected, long timeout, TimeUnit unit) {
+        return ts.awaitValueCount(expected, timeout, unit);
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertTerminalEvent()
+     */
+    @Override
+    public AssertableSubscriber<T> assertTerminalEvent() {
+        ts.assertTerminalEvent();
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertUnsubscribed()
+     */
+    @Override
+    public AssertableSubscriber<T> assertUnsubscribed() {
+        ts.assertUnsubscribed();
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertNoErrors()
+     */
+    @Override
+    public AssertableSubscriber<T> assertNoErrors() {
+        ts.assertNoErrors();
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#awaitTerminalEvent()
+     */
+    @Override
+    public AssertableSubscriber<T> awaitTerminalEvent() {
+        ts.awaitTerminalEvent();
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#awaitTerminalEvent(long, java.util.concurrent.TimeUnit)
+     */
+    @Override
+    public AssertableSubscriber<T> awaitTerminalEvent(long timeout, TimeUnit unit) {
+        ts.awaitTerminalEvent(timeout, unit);
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#awaitTerminalEventAndUnsubscribeOnTimeout(long, java.util.concurrent.TimeUnit)
+     */
+    @Override
+    public AssertableSubscriber<T> awaitTerminalEventAndUnsubscribeOnTimeout(long timeout,
+            TimeUnit unit) {
+        ts.awaitTerminalEventAndUnsubscribeOnTimeout(timeout, unit);
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#getLastSeenThread()
+     */
+    @Override
+    public Thread getLastSeenThread() {
+        return ts.getLastSeenThread();
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertCompleted()
+     */
+    @Override
+    public AssertableSubscriber<T> assertCompleted() {
+        ts.assertCompleted();
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertNotCompleted()
+     */
+    @Override
+    public AssertableSubscriber<T> assertNotCompleted() {
+        ts.assertNotCompleted();
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertError(java.lang.Class)
+     */
+    @Override
+    public AssertableSubscriber<T> assertError(Class<? extends Throwable> clazz) {
+        ts.assertError(clazz);
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertError(java.lang.Throwable)
+     */
+    @Override
+    public AssertableSubscriber<T> assertError(Throwable throwable) {
+        ts.assertError(throwable);
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertNoTerminalEvent()
+     */
+    @Override
+    public AssertableSubscriber<T> assertNoTerminalEvent() {
+        ts.assertNoTerminalEvent();
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertNoValues()
+     */
+    @Override
+    public AssertableSubscriber<T> assertNoValues() {
+        ts.assertNoValues();
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertValueCount(int)
+     */
+    @Override
+    public AssertableSubscriber<T> assertValueCount(int count) {
+        ts.assertValueCount(count);
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertValues(T)
+     */
+    @Override
+    public AssertableSubscriber<T> assertValues(T... values) {
+        ts.assertValues(values);
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertValue(T)
+     */
+    @Override
+    public AssertableSubscriber<T> assertValue(T value) {
+        ts.assertValue(value);
+        return this;
+    }
+    
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#assertValuesAndClear(T, T)
+     */
+    @Override
+    public final AssertableSubscriber<T> assertValuesAndClear(T expectedFirstValue,
+            T... expectedRestValues) {
+        ts.assertValuesAndClear(expectedFirstValue, expectedRestValues);
+        return this;
+    }
+
+    /* (non-Javadoc)
+     * @see rx.observers.AssertableSubscriber#perform(rx.functions.Action0)
+     */
+    @Override
+    public final AssertableSubscriber<T> perform(Action0 action) {
+        action.call();
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        return ts.toString();
+    }
+
+}
diff --git a/src/main/java/rx/observers/AssertableSubscriber.java b/src/main/java/rx/observers/AssertableSubscriber.java
new file mode 100644
index 0000000000..c4199088cb
--- /dev/null
+++ b/src/main/java/rx/observers/AssertableSubscriber.java
@@ -0,0 +1,87 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.observers;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import rx.Observer;
+import rx.Producer;
+import rx.functions.Action0;
+
+public interface AssertableSubscriber<T> extends Observer<T> {
+
+    void onStart();
+
+    void setProducer(Producer p);
+
+    int getCompletions();
+
+    List<Throwable> getOnErrorEvents();
+
+    int getValueCount();
+
+    AssertableSubscriber<T> requestMore(long n);
+
+    List<T> getOnNextEvents();
+
+    AssertableSubscriber<T> assertReceivedOnNext(List<T> items);
+
+    boolean awaitValueCount(int expected, long timeout, TimeUnit unit);
+
+    AssertableSubscriber<T> assertTerminalEvent();
+
+    AssertableSubscriber<T> assertUnsubscribed();
+
+    AssertableSubscriber<T> assertNoErrors();
+
+    AssertableSubscriber<T> awaitTerminalEvent();
+
+    AssertableSubscriber<T> awaitTerminalEvent(long timeout, TimeUnit unit);
+
+    AssertableSubscriber<T> awaitTerminalEventAndUnsubscribeOnTimeout(long timeout,
+            TimeUnit unit);
+
+    Thread getLastSeenThread();
+
+    AssertableSubscriber<T> assertCompleted();
+
+    AssertableSubscriber<T> assertNotCompleted();
+
+    AssertableSubscriber<T> assertError(Class<? extends Throwable> clazz);
+
+    AssertableSubscriber<T> assertError(Throwable throwable);
+
+    AssertableSubscriber<T> assertNoTerminalEvent();
+
+    AssertableSubscriber<T> assertNoValues();
+
+    AssertableSubscriber<T> assertValueCount(int count);
+
+    AssertableSubscriber<T> assertValues(T... values);
+
+    AssertableSubscriber<T> assertValue(T value);
+
+    AssertableSubscriber<T> assertValuesAndClear(T expectedFirstValue,
+            T... expectedRestValues);
+
+    AssertableSubscriber<T> perform(Action0 action);
+    
+    void unsubscribe();
+    
+    boolean isUnsubscribed();
+
+}
\ No newline at end of file
diff --git a/src/test/java/rx/observers/AssertableSubscriberTest.java b/src/test/java/rx/observers/AssertableSubscriberTest.java
new file mode 100644
index 0000000000..84128feada
--- /dev/null
+++ b/src/test/java/rx/observers/AssertableSubscriberTest.java
@@ -0,0 +1,162 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.observers;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.junit.Test;
+
+import rx.Completable;
+import rx.Observable;
+import rx.Single;
+import rx.functions.Action0;
+import rx.functions.Actions;
+
+public class AssertableSubscriberTest {
+
+    @Test
+    public void testManyMaxValue() {
+        AssertableSubscriber<Integer> ts = Observable.just(1, 2, 3) 
+            .test() 
+            .assertValues(1, 2, 3) 
+            .awaitTerminalEvent()
+            .awaitTerminalEvent(5, TimeUnit.SECONDS)
+            .awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS)
+            .assertCompleted() 
+            .assertTerminalEvent()
+            .assertNoErrors() 
+            .assertUnsubscribed() 
+            .assertReceivedOnNext(Arrays.asList(1, 2, 3)) 
+            .assertValueCount(3);
+        assertEquals(3, ts.getValueCount());
+        assertEquals(1, ts.getCompletions());
+        assertEquals(Thread.currentThread().getName(),  ts.getLastSeenThread().getName());
+        assertEquals(Arrays.asList(1,2,3), ts.getOnNextEvents());
+        assertTrue(ts.awaitValueCount(3, 5, TimeUnit.SECONDS));
+    }
+    
+    @Test
+    public void testManyWithInitialRequest() {
+        AssertableSubscriber<Integer> ts = Observable.just(1, 2, 3) 
+            .test(1) 
+            .assertValue(1)
+            .assertValues(1)
+            .assertValuesAndClear(1)
+            .assertNotCompleted()
+            .assertNoErrors()
+            .assertNoTerminalEvent()
+            .requestMore(1)
+            .assertValuesAndClear(2);
+        ts.unsubscribe();
+        ts.assertUnsubscribed();
+        assertTrue(ts.isUnsubscribed());
+    }
+    
+    @Test
+    public void testEmpty() {
+        Observable.empty()
+            .test()
+            .assertNoValues();
+    }
+
+    @Test
+    public void testError() {
+        IOException e = new IOException();
+        AssertableSubscriber<Object> ts = Observable.error(e)
+            .test()
+            .assertError(e)
+            .assertError(IOException.class);
+        assertEquals(Arrays.asList(e), ts.getOnErrorEvents());
+    }
+    
+    @Test
+    public void toStringIsNotNull() {
+        AssertableSubscriber<Object> ts = Observable.empty().test();
+        assertNotNull(ts.toString());
+    }
+    
+    @Test
+    public void testPerform() {
+        final AtomicBoolean performed = new AtomicBoolean(false);
+        Observable.empty()
+            .test()
+            .perform(new Action0() {
+                @Override
+                public void call() {
+                    performed.set(true);
+                }
+            });
+        assertTrue(performed.get());
+    }
+    
+    @Test
+    public void testCompletable() {
+        AssertableSubscriber<Void> ts = Completable
+            .fromAction(Actions.empty())
+            .test()
+            .assertNoValues()
+            .assertNoErrors()
+            .assertValueCount(0)
+            .assertValues()
+            .assertTerminalEvent()
+            .assertReceivedOnNext(Collections.<Void>emptyList())
+            .awaitTerminalEvent()
+            .awaitTerminalEvent(5, TimeUnit.SECONDS)
+            .awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS)
+            .assertCompleted()
+            .assertUnsubscribed();
+        assertEquals(1, ts.getCompletions());
+        assertEquals(Thread.currentThread().getName(), ts.getLastSeenThread().getName());
+        assertTrue(ts.getOnErrorEvents().isEmpty());
+        assertTrue(ts.getOnNextEvents().isEmpty());
+        assertEquals(0, ts.getValueCount());
+    }
+    
+    @Test
+    public void testSingle() {
+        AssertableSubscriber<Integer> ts = Single
+            .just(10)
+            .test()
+            .assertValue(10)
+            .assertValues(10)
+            .assertValueCount(1)
+            .assertReceivedOnNext(Arrays.asList(10))
+            .assertValuesAndClear(10)
+            .assertNoValues()
+            .assertTerminalEvent()
+            .assertNoErrors()
+            .assertCompleted()
+            .assertUnsubscribed()
+            .awaitTerminalEvent()
+            .awaitTerminalEvent(5, TimeUnit.SECONDS)
+            .awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS);
+       assertEquals(1, ts.getCompletions());
+       assertEquals(Thread.currentThread().getName(), ts.getLastSeenThread().getName());
+       assertTrue(ts.getOnErrorEvents().isEmpty());
+       assertTrue(ts.getOnNextEvents().isEmpty());
+       assertEquals(1, ts.getValueCount());
+    }
+    
+}
+

From 1f6c68c469359ec08842d3b540387682357325f1 Mon Sep 17 00:00:00 2001
From: George Campbell <abersnaze@gmail.com>
Date: Wed, 9 Nov 2016 14:55:03 -0800
Subject: [PATCH 192/263] Schedule when bug fix (#4826)

* change tabs to spaces.

* Fixing a bug in the subscription logic of the actions that caused work to get unsubscribed too early. Changed the code to delay the calling of onCompleted of the CompletableSubscriber until the actualAction is truly done.
---
 .../rx/internal/schedulers/SchedulerWhen.java | 400 +++++++++---------
 .../java/rx/schedulers/SchedulerWhenTest.java |  15 +
 2 files changed, 224 insertions(+), 191 deletions(-)

diff --git a/src/main/java/rx/internal/schedulers/SchedulerWhen.java b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
index db1006f885..c45ee5853c 100644
--- a/src/main/java/rx/internal/schedulers/SchedulerWhen.java
+++ b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
@@ -104,195 +104,213 @@
  */
 @Experimental
 public class SchedulerWhen extends Scheduler implements Subscription {
-	private final Scheduler actualScheduler;
-	private final Observer<Observable<Completable>> workerObserver;
-	private final Subscription subscription;
-
-	public SchedulerWhen(Func1<Observable<Observable<Completable>>, Completable> combine, Scheduler actualScheduler) {
-		this.actualScheduler = actualScheduler;
-		// workers are converted into completables and put in this queue.
-		PublishSubject<Observable<Completable>> workerSubject = PublishSubject.create();
-		this.workerObserver = new SerializedObserver<Observable<Completable>>(workerSubject);
-		// send it to a custom combinator to pick the order and rate at which
-		// workers are processed.
-		this.subscription = combine.call(workerSubject.onBackpressureBuffer()).subscribe();
-	}
-
-	@Override
-	public void unsubscribe() {
-		subscription.unsubscribe();
-	}
-
-	@Override
-	public boolean isUnsubscribed() {
-		return subscription.isUnsubscribed();
-	}
-
-	@Override
-	public Worker createWorker() {
-		final Worker actualWorker = actualScheduler.createWorker();
-		// a queue for the actions submitted while worker is waiting to get to
-		// the subscribe to off the workerQueue.
-		BufferUntilSubscriber<ScheduledAction> actionSubject = BufferUntilSubscriber.<ScheduledAction>create();
-		final Observer<ScheduledAction> actionObserver = new SerializedObserver<ScheduledAction>(actionSubject);
-		// convert the work of scheduling all the actions into a completable
-		Observable<Completable> actions = actionSubject.map(new Func1<ScheduledAction, Completable>() {
-			@Override
-			public Completable call(final ScheduledAction action) {
-				return Completable.create(new OnSubscribe() {
-					@Override
-					public void call(CompletableSubscriber actionCompletable) {
-						actionCompletable.onSubscribe(action);
-						action.call(actualWorker);
-						actionCompletable.onCompleted();
-					}
-				});
-			}
-		});
-
-		// a worker that queues the action to the actionQueue subject.
-		Worker worker = new Worker() {
-			private final AtomicBoolean unsubscribed = new AtomicBoolean();
-
-			@Override
-			public void unsubscribe() {
-				// complete the actionQueue when worker is unsubscribed to make
-				// room for the next worker in the workerQueue.
-				if (unsubscribed.compareAndSet(false, true)) {
-					actualWorker.unsubscribe();
-					actionObserver.onCompleted();
-				}
-			}
-
-			@Override
-			public boolean isUnsubscribed() {
-				return unsubscribed.get();
-			}
-
-			@Override
-			public Subscription schedule(final Action0 action, final long delayTime, final TimeUnit unit) {
-				// send a scheduled action to the actionQueue
-				DelayedAction delayedAction = new DelayedAction(action, delayTime, unit);
-				actionObserver.onNext(delayedAction);
-				return delayedAction;
-			}
-
-			@Override
-			public Subscription schedule(final Action0 action) {
-				// send a scheduled action to the actionQueue
-				ImmediateAction immediateAction = new ImmediateAction(action);
-				actionObserver.onNext(immediateAction);
-				return immediateAction;
-			}
-		};
-
-		// enqueue the completable that process actions put in reply subject
-		workerObserver.onNext(actions);
-
-		// return the worker that adds actions to the reply subject
-		return worker;
-	}
-
-	static final Subscription SUBSCRIBED = new Subscription() {
-		@Override
-		public void unsubscribe() {
-		}
-
-		@Override
-		public boolean isUnsubscribed() {
-			return false;
-		}
-	};
-
-	static final Subscription UNSUBSCRIBED = Subscriptions.unsubscribed();
-
-	@SuppressWarnings("serial")
-	private static abstract class ScheduledAction extends AtomicReference<Subscription> implements Subscription {
-		public ScheduledAction() {
-			super(SUBSCRIBED);
-		}
-
-		private void call(Worker actualWorker) {
-			Subscription oldState = get();
-			// either SUBSCRIBED or UNSUBSCRIBED
-			if (oldState == UNSUBSCRIBED) {
-				// no need to schedule return
-				return;
-			}
-			if (oldState != SUBSCRIBED) {
-				// has already been scheduled return
-				// should not be able to get here but handle it anyway by not
-				// rescheduling.
-				return;
-			}
-
-			Subscription newState = callActual(actualWorker);
-
-			if (!compareAndSet(SUBSCRIBED, newState)) {
-				// set would only fail if the new current state is some other
-				// subscription from a concurrent call to this method.
-				// Unsubscribe from the action just scheduled because it lost
-				// the race.
-				newState.unsubscribe();
-			}
-		}
-
-		protected abstract Subscription callActual(Worker actualWorker);
-
-		@Override
-		public boolean isUnsubscribed() {
-			return get().isUnsubscribed();
-		}
-
-		@Override
-		public void unsubscribe() {
-			Subscription oldState;
-			// no matter what the current state is the new state is going to be
-			Subscription newState = UNSUBSCRIBED;
-			do {
-				oldState = get();
-				if (oldState == UNSUBSCRIBED) {
-					// the action has already been unsubscribed
-					return;
-				}
-			} while (!compareAndSet(oldState, newState));
-
-			if (oldState != SUBSCRIBED) {
-				// the action was scheduled. stop it.
-				oldState.unsubscribe();
-			}
-		}
-	}
-
-	@SuppressWarnings("serial")
-	private static class ImmediateAction extends ScheduledAction {
-		private final Action0 action;
-
-		public ImmediateAction(Action0 action) {
-			this.action = action;
-		}
-
-		@Override
-		protected Subscription callActual(Worker actualWorker) {
-			return actualWorker.schedule(action);
-		}
-	}
-
-	@SuppressWarnings("serial")
-	private static class DelayedAction extends ScheduledAction {
-		private final Action0 action;
-		private final long delayTime;
-		private final TimeUnit unit;
-
-		public DelayedAction(Action0 action, long delayTime, TimeUnit unit) {
-			this.action = action;
-			this.delayTime = delayTime;
-			this.unit = unit;
-		}
-
-		@Override
-		protected Subscription callActual(Worker actualWorker) {
-			return actualWorker.schedule(action, delayTime, unit);
-		}
-	}
+    private final Scheduler actualScheduler;
+    private final Observer<Observable<Completable>> workerObserver;
+    private final Subscription subscription;
+
+    public SchedulerWhen(Func1<Observable<Observable<Completable>>, Completable> combine, Scheduler actualScheduler) {
+        this.actualScheduler = actualScheduler;
+        // workers are converted into completables and put in this queue.
+        PublishSubject<Observable<Completable>> workerSubject = PublishSubject.create();
+        this.workerObserver = new SerializedObserver<Observable<Completable>>(workerSubject);
+        // send it to a custom combinator to pick the order and rate at which
+        // workers are processed.
+        this.subscription = combine.call(workerSubject.onBackpressureBuffer()).subscribe();
+    }
+
+    @Override
+    public void unsubscribe() {
+        subscription.unsubscribe();
+    }
+
+    @Override
+    public boolean isUnsubscribed() {
+        return subscription.isUnsubscribed();
+    }
+
+    @Override
+    public Worker createWorker() {
+        final Worker actualWorker = actualScheduler.createWorker();
+        // a queue for the actions submitted while worker is waiting to get to
+        // the subscribe to off the workerQueue.
+        BufferUntilSubscriber<ScheduledAction> actionSubject = BufferUntilSubscriber.<ScheduledAction> create();
+        final Observer<ScheduledAction> actionObserver = new SerializedObserver<ScheduledAction>(actionSubject);
+        // convert the work of scheduling all the actions into a completable
+        Observable<Completable> actions = actionSubject.map(new Func1<ScheduledAction, Completable>() {
+            @Override
+            public Completable call(final ScheduledAction action) {
+                return Completable.create(new OnSubscribe() {
+                    @Override
+                    public void call(CompletableSubscriber actionCompletable) {
+                        actionCompletable.onSubscribe(action);
+                        action.call(actualWorker, actionCompletable);
+                    }
+                });
+            }
+        });
+
+        // a worker that queues the action to the actionQueue subject.
+        Worker worker = new Worker() {
+            private final AtomicBoolean unsubscribed = new AtomicBoolean();
+
+            @Override
+            public void unsubscribe() {
+                // complete the actionQueue when worker is unsubscribed to make
+                // room for the next worker in the workerQueue.
+                if (unsubscribed.compareAndSet(false, true)) {
+                    actualWorker.unsubscribe();
+                    actionObserver.onCompleted();
+                }
+            }
+
+            @Override
+            public boolean isUnsubscribed() {
+                return unsubscribed.get();
+            }
+
+            @Override
+            public Subscription schedule(final Action0 action, final long delayTime, final TimeUnit unit) {
+                // send a scheduled action to the actionQueue
+                DelayedAction delayedAction = new DelayedAction(action, delayTime, unit);
+                actionObserver.onNext(delayedAction);
+                return delayedAction;
+            }
+
+            @Override
+            public Subscription schedule(final Action0 action) {
+                // send a scheduled action to the actionQueue
+                ImmediateAction immediateAction = new ImmediateAction(action);
+                actionObserver.onNext(immediateAction);
+                return immediateAction;
+            }
+        };
+
+        // enqueue the completable that process actions put in reply subject
+        workerObserver.onNext(actions);
+
+        // return the worker that adds actions to the reply subject
+        return worker;
+    }
+
+    static final Subscription SUBSCRIBED = new Subscription() {
+        @Override
+        public void unsubscribe() {
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return false;
+        }
+    };
+
+    static final Subscription UNSUBSCRIBED = Subscriptions.unsubscribed();
+
+    @SuppressWarnings("serial")
+    private static abstract class ScheduledAction extends AtomicReference<Subscription>implements Subscription {
+        public ScheduledAction() {
+            super(SUBSCRIBED);
+        }
+
+        private void call(Worker actualWorker, CompletableSubscriber actionCompletable) {
+            Subscription oldState = get();
+            // either SUBSCRIBED or UNSUBSCRIBED
+            if (oldState == UNSUBSCRIBED) {
+                // no need to schedule return
+                return;
+            }
+            if (oldState != SUBSCRIBED) {
+                // has already been scheduled return
+                // should not be able to get here but handle it anyway by not
+                // rescheduling.
+                return;
+            }
+
+            Subscription newState = callActual(actualWorker, actionCompletable);
+
+            if (!compareAndSet(SUBSCRIBED, newState)) {
+                // set would only fail if the new current state is some other
+                // subscription from a concurrent call to this method.
+                // Unsubscribe from the action just scheduled because it lost
+                // the race.
+                newState.unsubscribe();
+            }
+        }
+
+        protected abstract Subscription callActual(Worker actualWorker, CompletableSubscriber actionCompletable);
+
+        @Override
+        public boolean isUnsubscribed() {
+            return get().isUnsubscribed();
+        }
+
+        @Override
+        public void unsubscribe() {
+            Subscription oldState;
+            // no matter what the current state is the new state is going to be
+            Subscription newState = UNSUBSCRIBED;
+            do {
+                oldState = get();
+                if (oldState == UNSUBSCRIBED) {
+                    // the action has already been unsubscribed
+                    return;
+                }
+            } while (!compareAndSet(oldState, newState));
+
+            if (oldState != SUBSCRIBED) {
+                // the action was scheduled. stop it.
+                oldState.unsubscribe();
+            }
+        }
+    }
+
+    @SuppressWarnings("serial")
+    private static class ImmediateAction extends ScheduledAction {
+        private final Action0 action;
+
+        public ImmediateAction(Action0 action) {
+            this.action = action;
+        }
+
+        @Override
+        protected Subscription callActual(Worker actualWorker, CompletableSubscriber actionCompletable) {
+            return actualWorker.schedule(new OnCompletedAction(action, actionCompletable));
+        }
+    }
+
+    @SuppressWarnings("serial")
+    private static class DelayedAction extends ScheduledAction {
+        private final Action0 action;
+        private final long delayTime;
+        private final TimeUnit unit;
+
+        public DelayedAction(Action0 action, long delayTime, TimeUnit unit) {
+            this.action = action;
+            this.delayTime = delayTime;
+            this.unit = unit;
+        }
+
+        @Override
+        protected Subscription callActual(Worker actualWorker, CompletableSubscriber actionCompletable) {
+            return actualWorker.schedule(new OnCompletedAction(action, actionCompletable), delayTime, unit);
+        }
+    }
+
+    private static class OnCompletedAction implements Action0 {
+        private CompletableSubscriber actionCompletable;
+        private Action0 action;
+
+        public OnCompletedAction(Action0 action, CompletableSubscriber actionCompletable) {
+            this.action = action;
+            this.actionCompletable = actionCompletable;
+        }
+
+        @Override
+        public void call() {
+            try {
+                action.call();
+            } finally {
+                actionCompletable.onCompleted();
+            }
+        }
+    }
 }
diff --git a/src/test/java/rx/schedulers/SchedulerWhenTest.java b/src/test/java/rx/schedulers/SchedulerWhenTest.java
index 49ff840e65..ed0e2f3792 100644
--- a/src/test/java/rx/schedulers/SchedulerWhenTest.java
+++ b/src/test/java/rx/schedulers/SchedulerWhenTest.java
@@ -16,6 +16,8 @@
 package rx.schedulers;
 
 import static java.util.concurrent.TimeUnit.SECONDS;
+import static rx.Observable.just;
+import static rx.Observable.merge;
 
 import org.junit.Test;
 
@@ -204,4 +206,17 @@ public Completable call(Completable worker) {
 		}, tSched);
 		return sched;
 	}
+
+    @Test(timeout=1000)
+    public void testRaceConditions() {
+        Scheduler comp = Schedulers.computation();
+        Scheduler limited = comp.when(new Func1<Observable<Observable<Completable>>, Completable>() {
+            @Override
+            public Completable call(Observable<Observable<Completable>> t) {
+                return Completable.merge(Observable.merge(t, 10));
+            }
+        });
+
+        merge(just(just(1).subscribeOn(limited).observeOn(comp)).repeat(1000)).toBlocking().subscribe();
+    }
 }

From eb58e5c849b04f7f46f0984ac95c31cb102de0d5 Mon Sep 17 00:00:00 2001
From: George Campbell <abersnaze@gmail.com>
Date: Thu, 10 Nov 2016 00:01:36 -0800
Subject: [PATCH 193/263] changing inner classes to package-private. (#4828)

---
 src/main/java/rx/internal/schedulers/SchedulerWhen.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/main/java/rx/internal/schedulers/SchedulerWhen.java b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
index c45ee5853c..1310a96e08 100644
--- a/src/main/java/rx/internal/schedulers/SchedulerWhen.java
+++ b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
@@ -206,7 +206,7 @@ public boolean isUnsubscribed() {
     static final Subscription UNSUBSCRIBED = Subscriptions.unsubscribed();
 
     @SuppressWarnings("serial")
-    private static abstract class ScheduledAction extends AtomicReference<Subscription>implements Subscription {
+    static abstract class ScheduledAction extends AtomicReference<Subscription>implements Subscription {
         public ScheduledAction() {
             super(SUBSCRIBED);
         }
@@ -264,7 +264,7 @@ public void unsubscribe() {
     }
 
     @SuppressWarnings("serial")
-    private static class ImmediateAction extends ScheduledAction {
+    static class ImmediateAction extends ScheduledAction {
         private final Action0 action;
 
         public ImmediateAction(Action0 action) {
@@ -278,7 +278,7 @@ protected Subscription callActual(Worker actualWorker, CompletableSubscriber act
     }
 
     @SuppressWarnings("serial")
-    private static class DelayedAction extends ScheduledAction {
+    static class DelayedAction extends ScheduledAction {
         private final Action0 action;
         private final long delayTime;
         private final TimeUnit unit;
@@ -295,7 +295,7 @@ protected Subscription callActual(Worker actualWorker, CompletableSubscriber act
         }
     }
 
-    private static class OnCompletedAction implements Action0 {
+    static class OnCompletedAction implements Action0 {
         private CompletableSubscriber actionCompletable;
         private Action0 action;
 

From bebdec6a52955ea478a992cebbd527364cb5b6a4 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 10 Nov 2016 09:13:06 +0100
Subject: [PATCH 194/263] 1.x: update AssertableSubscriber API and add Javadoc
 (#4824)

---
 src/main/java/rx/Completable.java             |   2 +-
 src/main/java/rx/Observable.java              |   5 +-
 .../AssertableSubscriberObservable.java       |  39 ++-
 .../rx/observers/AssertableSubscriber.java    | 202 +++++++++++++++-
 .../observers/AssertableSubscriberTest.java   | 228 ++++++++++++++++--
 5 files changed, 438 insertions(+), 38 deletions(-)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 12d088c35d..37191e3b12 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -2365,7 +2365,7 @@ public void call() {
             }
         });
     }
-    
+
     // -------------------------------------------------------------------------
     // Fluent test support, super handy and reduces test preparation boilerplate
     // -------------------------------------------------------------------------
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 904ccec45c..0d25f8f3f2 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -12642,7 +12642,7 @@ public final <T2, R> Observable<R> zipWith(Iterable<? extends T2> other, Func2<?
     public final <T2, R> Observable<R> zipWith(Observable<? extends T2> other, Func2<? super T, ? super T2, ? extends R> zipFunction) {
         return (Observable<R>)zip(this, other, zipFunction);
     }
-    
+
     // -------------------------------------------------------------------------
     // Fluent test support, super handy and reduces test preparation boilerplate
     // -------------------------------------------------------------------------
@@ -12664,7 +12664,7 @@ public final AssertableSubscriber<T> test() {
         subscribe(ts);
         return ts;
     }
-    
+
     /**
      * Creates an AssertableSubscriber with the initial request amount and subscribes
      * it to this Observable.
@@ -12675,6 +12675,7 @@ public final AssertableSubscriber<T> test() {
      *  <dd>{@code test} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      * @return the new AssertableSubscriber instance
+     * @param initialRequestAmount the amount to request from upstream upfront, non-negative (not verified)
      * @since 1.2.3
      */
     @Experimental
diff --git a/src/main/java/rx/internal/observers/AssertableSubscriberObservable.java b/src/main/java/rx/internal/observers/AssertableSubscriberObservable.java
index db1c4f0532..b9068b04ff 100644
--- a/src/main/java/rx/internal/observers/AssertableSubscriberObservable.java
+++ b/src/main/java/rx/internal/observers/AssertableSubscriberObservable.java
@@ -135,8 +135,11 @@ public AssertableSubscriber<T> assertReceivedOnNext(List<T> items) {
      * @see rx.observers.AssertableSubscriber#awaitValueCount(int, long, java.util.concurrent.TimeUnit)
      */
     @Override
-    public final boolean awaitValueCount(int expected, long timeout, TimeUnit unit) {
-        return ts.awaitValueCount(expected, timeout, unit);
+    public final AssertableSubscriber<T> awaitValueCount(int expected, long timeout, TimeUnit unit) {
+        if (!ts.awaitValueCount(expected, timeout, unit)) {
+            throw new AssertionError("Did not receive enough values in time. Expected: " + expected + ", Actual: " + ts.getValueCount());
+        }
+        return this;
     }
 
     /* (non-Javadoc)
@@ -282,7 +285,7 @@ public AssertableSubscriber<T> assertValue(T value) {
         ts.assertValue(value);
         return this;
     }
-    
+
     /* (non-Javadoc)
      * @see rx.observers.AssertableSubscriber#assertValuesAndClear(T, T)
      */
@@ -307,4 +310,34 @@ public String toString() {
         return ts.toString();
     }
 
+    @Override
+    public final AssertableSubscriber<T> assertResult(T... values) {
+        ts.assertValues(values);
+        ts.assertNoErrors();
+        ts.assertCompleted();
+        return this;
+    }
+
+    @Override
+    public final AssertableSubscriber<T> assertFailure(Class<? extends Throwable> errorClass, T... values) {
+        ts.assertValues(values);
+        ts.assertError(errorClass);
+        ts.assertNotCompleted();
+        return this;
+    }
+
+    @Override
+    public final AssertableSubscriber<T> assertFailureAndMessage(Class<? extends Throwable> errorClass, String message,
+            T... values) {
+        ts.assertValues(values);
+        ts.assertError(errorClass);
+        ts.assertNotCompleted();
+
+        String actualMessage = ts.getOnErrorEvents().get(0).getMessage();
+        if (!(actualMessage == message || (message != null && message.equals(actualMessage)))) {
+            throw new AssertionError("Error message differs. Expected: \'" + message + "\', Received: \'" + actualMessage + "\'");
+        }
+
+        return this;
+    }
 }
diff --git a/src/main/java/rx/observers/AssertableSubscriber.java b/src/main/java/rx/observers/AssertableSubscriber.java
index c4199088cb..756d3049d0 100644
--- a/src/main/java/rx/observers/AssertableSubscriber.java
+++ b/src/main/java/rx/observers/AssertableSubscriber.java
@@ -18,70 +18,260 @@
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
-import rx.Observer;
-import rx.Producer;
+import rx.*;
+import rx.annotations.Experimental;
 import rx.functions.Action0;
 
-public interface AssertableSubscriber<T> extends Observer<T> {
+/**
+ * Interface for asserting the state of a sequence under testing with a {@code test()}
+ * method of a reactive base class.
+ * <p>
+ * This interface is not intended to be implemented outside of RxJava.
+ * <p>
+ * This interface extends {@link Observer} and allows injecting onXXX signals into
+ * the testing process.
+ * @param <T> the value type consumed by this Observer
+ * @since 1.2.3
+ */
+@Experimental
+public interface AssertableSubscriber<T> extends Observer<T>, Subscription {
 
+    /**
+     * Allows manually calling the {@code onStart} method of the underlying Subscriber.
+     */
     void onStart();
 
+    /**
+     * Allows manually calling the {@code setProducer} method of the underlying Subscriber.
+     * @param p the producer to use, not null
+     */
     void setProducer(Producer p);
 
+    /**
+     * Returns the number of {@code onCompleted} signals received by this Observer.
+     * @return the number of {@code onCompleted} signals received
+     */
     int getCompletions();
 
+    /**
+     * Returns a list of received {@code onError} signals.
+     * @return this
+     */
     List<Throwable> getOnErrorEvents();
 
+    /**
+     * Returns the number of {@code onNext} signals received by this Observer in
+     * a thread-safe manner; one can read up to this number of elements from
+     * the {@code List} returned by {@link #getOnNextEvents()}.
+     * @return the number of {@code onNext} signals received.
+     */
     int getValueCount();
 
+    /**
+     * Requests the specified amount of items from upstream.
+     * @param n the amount requested, non-negative
+     * @return this
+     */
     AssertableSubscriber<T> requestMore(long n);
 
+    /**
+     * Returns the list of received {@code onNext} events.
+     * <p>If the sequence hasn't completed yet and is asynchronous, use the
+     * {@link #getValueCount()} method to determine how many elements are safe
+     * to be read from the list returned by this method.
+     * @return the List of received {@code onNext} events.
+     */
     List<T> getOnNextEvents();
 
+    /**
+     * Assert that this Observer received the given list of items as {@code onNext} signals
+     * in the same order and with the default null-safe object equals comparison.
+     * @param items the List of items expected
+     * @return this
+     */
     AssertableSubscriber<T> assertReceivedOnNext(List<T> items);
 
-    boolean awaitValueCount(int expected, long timeout, TimeUnit unit);
+    /**
+     * Assert that this Observer receives at least the given number of {@code onNext}
+     * signals within the specified timeout period.
+     * <p>
+     * Note that it is possible the AssertionError thrown by this method will
+     * contain an actual value &gt;= to the expected one in case there is an emission
+     * race or unexpected delay on the emitter side. In this case, increase the timeout
+     * amount to avoid false positives.
+     *
+     * @param expected the expected (at least) number of {@code onNext} signals
+     * @param timeout the timeout to wait to receive the given number of {@code onNext} events
+     * @param unit the time unit
+     * @return this
+     */
+    AssertableSubscriber<T> awaitValueCount(int expected, long timeout, TimeUnit unit);
 
+    /**
+     * Assert that this Observer received either an {@code onError} or {@code onCompleted} signal.
+     * @return this
+     */
     AssertableSubscriber<T> assertTerminalEvent();
 
+    /**
+     * Assert that this Observer has been unsubscribed via {@code unsubscribe()} or by a wrapping
+     * {@code SafeSubscriber}.
+     * @return this
+     */
     AssertableSubscriber<T> assertUnsubscribed();
 
+    /**
+     * Assert that this Observer has not received any {@code onError} signal.
+     * @return this
+     */
     AssertableSubscriber<T> assertNoErrors();
 
+    /**
+     * Waits for an {@code onError} or {code onCompleted} terminal event indefinitely.
+     * @return this
+     */
     AssertableSubscriber<T> awaitTerminalEvent();
 
+
+    /**
+     * Waits for an {@code onError} or {code onCompleted} terminal event for the given
+     * amount of timeout.
+     * @param timeout the time to wait for the terminal event
+     * @param unit the time unit of the wait time
+     * @return this
+     */
     AssertableSubscriber<T> awaitTerminalEvent(long timeout, TimeUnit unit);
 
+    /**
+     * Waits for an {@code onError} or {code onCompleted} terminal event for the given
+     * amount of timeout and unsubscribes the sequence if the timeout passed or the
+     * wait itself is interrupted.
+     * @param timeout the time to wait for the terminal event
+     * @param unit the time unit of the wait time
+     * @return this
+     */
     AssertableSubscriber<T> awaitTerminalEventAndUnsubscribeOnTimeout(long timeout,
             TimeUnit unit);
 
+    /**
+     * Returns the Thread that has called the last {@code onNext}, {@code onError} or
+     * {@code onCompleted} methods of this Observer.
+     * @return this
+     */
     Thread getLastSeenThread();
 
+    /**
+     * Assert that this Observer received exaclty one {@code onCompleted} signal.
+     * @return this
+     */
     AssertableSubscriber<T> assertCompleted();
 
+    /**
+     * Assert that this Observer received no {@code onCompleted} signal.
+     * @return this
+     */
     AssertableSubscriber<T> assertNotCompleted();
 
+    /**
+     * Assert that this Observer received one {@code onError} signal with
+     * the given subclass of a Throwable as type.
+     * @param clazz the expected type of the {@code onError} signal received
+     * @return this
+     */
     AssertableSubscriber<T> assertError(Class<? extends Throwable> clazz);
 
+    /**
+     * Assert that this Observer received one {@code onError} signal with the
+     * object-equals of the given Throwable instance
+     * @param throwable the Throwable instance expected
+     * @return this
+     */
     AssertableSubscriber<T> assertError(Throwable throwable);
 
+    /**
+     * Assert that no {@code onError} or {@code onCompleted} signals were received so far.
+     * @return this
+     */
     AssertableSubscriber<T> assertNoTerminalEvent();
 
+    /**
+     * Assert that no {@code onNext} signals were received so far.
+     * @return this
+     */
     AssertableSubscriber<T> assertNoValues();
 
+    /**
+     * Assert that this Observer received exactly the given count of
+     * {@code onNext} signals.
+     * @param count the expected number of {@code onNext} signals
+     * @return this
+     */
     AssertableSubscriber<T> assertValueCount(int count);
 
+    /**
+     * Assert that this Observer received exactly the given expected values
+     * (compared via null-safe object equals) in the given order.
+     * @param values the expected values
+     * @return this
+     */
     AssertableSubscriber<T> assertValues(T... values);
 
+    /**
+     * Assert that this Observer received exactly the given single expected value
+     * (compared via null-safe object equals).
+     * @param value the single value expected
+     * @return this
+     */
     AssertableSubscriber<T> assertValue(T value);
 
+    /**
+     * Assert that this Observer received exactly the given values (compared via
+     * null-safe object equals) and if so, clears the internal buffer of the
+     * underlying Subscriber of these values.
+     * @param expectedFirstValue the first value expected
+     * @param expectedRestValues the rest of the values expected
+     * @return this
+     */
     AssertableSubscriber<T> assertValuesAndClear(T expectedFirstValue,
             T... expectedRestValues);
 
+    /**
+     * Performs an action given by the Action0 callback in a fluent manner.
+     * @param action the action to perform, not null
+     * @return this
+     */
     AssertableSubscriber<T> perform(Action0 action);
-    
+
+    @Override
     void unsubscribe();
-    
+
+    @Override
     boolean isUnsubscribed();
 
+    /**
+     * Assert that this Observer received the specified items in the given order followed
+     * by a completion signal and no errors.
+     * @param values the values expected
+     * @return this
+     */
+    AssertableSubscriber<T> assertResult(T... values);
+
+    /**
+     * Assert that this Observer received the specified items in the given order followed
+     * by an error signal of the given type (but no completion signal).
+     * @param errorClass the expected Throwable subclass type
+     * @param values the expected values
+     * @return this
+     */
+    AssertableSubscriber<T> assertFailure(Class<? extends Throwable> errorClass, T... values);
+
+    /**
+     * Assert that this Observer received the specified items in the given order followed
+     * by an error signal of the given type and with the exact error message (but no completion signal).
+     * @param errorClass the expected Throwable subclass type
+     * @param message the expected error message returned by {@link Throwable#getMessage()}
+     * @param values the expected values
+     * @return this
+     */
+    AssertableSubscriber<T> assertFailureAndMessage(Class<? extends Throwable> errorClass, String message, T... values);
 }
\ No newline at end of file
diff --git a/src/test/java/rx/observers/AssertableSubscriberTest.java b/src/test/java/rx/observers/AssertableSubscriberTest.java
index 84128feada..838f57d6ec 100644
--- a/src/test/java/rx/observers/AssertableSubscriberTest.java
+++ b/src/test/java/rx/observers/AssertableSubscriberTest.java
@@ -15,51 +15,47 @@
  */
 package rx.observers;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 
 import java.io.IOException;
-import java.util.Arrays;
-import java.util.Collections;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 
-import rx.Completable;
+import rx.*;
 import rx.Observable;
-import rx.Single;
-import rx.functions.Action0;
-import rx.functions.Actions;
+import rx.exceptions.TestException;
+import rx.functions.*;
 
 public class AssertableSubscriberTest {
 
     @Test
     public void testManyMaxValue() {
-        AssertableSubscriber<Integer> ts = Observable.just(1, 2, 3) 
-            .test() 
-            .assertValues(1, 2, 3) 
+        AssertableSubscriber<Integer> ts = Observable.just(1, 2, 3)
+            .test()
+            .assertValues(1, 2, 3)
             .awaitTerminalEvent()
             .awaitTerminalEvent(5, TimeUnit.SECONDS)
             .awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS)
-            .assertCompleted() 
+            .assertCompleted()
             .assertTerminalEvent()
-            .assertNoErrors() 
-            .assertUnsubscribed() 
-            .assertReceivedOnNext(Arrays.asList(1, 2, 3)) 
+            .assertNoErrors()
+            .assertUnsubscribed()
+            .assertReceivedOnNext(Arrays.asList(1, 2, 3))
             .assertValueCount(3);
         assertEquals(3, ts.getValueCount());
         assertEquals(1, ts.getCompletions());
         assertEquals(Thread.currentThread().getName(),  ts.getLastSeenThread().getName());
         assertEquals(Arrays.asList(1,2,3), ts.getOnNextEvents());
-        assertTrue(ts.awaitValueCount(3, 5, TimeUnit.SECONDS));
+        ts.awaitValueCount(3, 5, TimeUnit.SECONDS);
     }
-    
+
     @Test
     public void testManyWithInitialRequest() {
-        AssertableSubscriber<Integer> ts = Observable.just(1, 2, 3) 
-            .test(1) 
+        AssertableSubscriber<Integer> ts = Observable.just(1, 2, 3)
+            .test(1)
             .assertValue(1)
             .assertValues(1)
             .assertValuesAndClear(1)
@@ -72,7 +68,7 @@ public void testManyWithInitialRequest() {
         ts.assertUnsubscribed();
         assertTrue(ts.isUnsubscribed());
     }
-    
+
     @Test
     public void testEmpty() {
         Observable.empty()
@@ -89,13 +85,13 @@ public void testError() {
             .assertError(IOException.class);
         assertEquals(Arrays.asList(e), ts.getOnErrorEvents());
     }
-    
+
     @Test
     public void toStringIsNotNull() {
         AssertableSubscriber<Object> ts = Observable.empty().test();
         assertNotNull(ts.toString());
     }
-    
+
     @Test
     public void testPerform() {
         final AtomicBoolean performed = new AtomicBoolean(false);
@@ -109,7 +105,7 @@ public void call() {
             });
         assertTrue(performed.get());
     }
-    
+
     @Test
     public void testCompletable() {
         AssertableSubscriber<Void> ts = Completable
@@ -132,7 +128,7 @@ public void testCompletable() {
         assertTrue(ts.getOnNextEvents().isEmpty());
         assertEquals(0, ts.getValueCount());
     }
-    
+
     @Test
     public void testSingle() {
         AssertableSubscriber<Integer> ts = Single
@@ -157,6 +153,186 @@ public void testSingle() {
        assertTrue(ts.getOnNextEvents().isEmpty());
        assertEquals(1, ts.getValueCount());
     }
-    
+
+    @Test
+    public void assertResult() {
+        Observable.just(1)
+        .test()
+        .assertResult(1);
+    }
+
+    @Test
+    public void assertResultFail() {
+        try {
+            Observable.just(1)
+            .test()
+            .assertResult(2);
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.just(1)
+            .test()
+            .assertResult();
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.never()
+            .test()
+            .assertResult(1);
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.error(new TestException())
+            .test()
+            .assertResult(2);
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+    }
+
+    @Test
+    public void assertFailure() {
+        Observable.error(new TestException())
+        .test()
+        .assertFailure(TestException.class);
+
+        Observable.just(1).concatWith(Observable.<Integer>error(new TestException()))
+        .test()
+        .assertFailure(TestException.class, 1);
+    }
+
+    @Test
+    public void assertFailureFail() {
+        try {
+            Observable.error(new TestException())
+            .test()
+            .assertFailure(IOException.class);
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.just(1)
+            .test()
+            .assertFailure(IOException.class);
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.just(1)
+            .test()
+            .assertFailure(IOException.class, 1);
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.empty()
+            .test()
+            .assertFailure(IOException.class, 1);
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+    }
+
+    @Test
+    public void assertFailureAndMessage() {
+        Observable.error(new TestException("forced failure"))
+        .test()
+        .assertFailureAndMessage(TestException.class, "forced failure");
+
+        Observable.just(1).concatWith(Observable.<Integer>error(new TestException("forced failure 2")))
+        .test()
+        .assertFailureAndMessage(TestException.class, "forced failure 2", 1);
+    }
+
+    @Test
+    public void assertFailureAndMessageFail() {
+        try {
+            Observable.error(new TestException())
+            .test()
+            .assertFailureAndMessage(IOException.class, "forced failure");
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+        try {
+            Observable.error(new TestException("forced failure"))
+            .test()
+            .assertFailureAndMessage(IOException.class, "forced failure");
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.just(1)
+            .test()
+            .assertFailureAndMessage(IOException.class, "forced failure");
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.just(1)
+            .test()
+            .assertFailureAndMessage(IOException.class, "forced failure", 1);
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.empty()
+            .test()
+            .assertFailureAndMessage(IOException.class, "forced failure", 1);
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.error(new TestException("failure forced"))
+            .test()
+            .assertFailureAndMessage(TestException.class, "forced failure");
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.just(1).concatWith(Observable.<Integer>error(new TestException("failure forced")))
+            .test()
+            .assertFailureAndMessage(TestException.class, "forced failure", 1);
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+
+        try {
+            Observable.just(1).concatWith(Observable.<Integer>error(new TestException()))
+            .test()
+            .assertFailureAndMessage(TestException.class, "forced failure", 1);
+            throw new RuntimeException("Should have thrown!"); // fail() doesn't work here because it also throws AssertionError and may look like the test passed
+        } catch (AssertionError ex) {
+            // expected
+        }
+    }
 }
 

From 2cdf1c071cb7a69295fefa381f37504af76d2e83 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 10 Nov 2016 15:22:25 +0100
Subject: [PATCH 195/263] 1.x: Completable.doAfterTerminate to run after
 onError as well (#4830)

---
 src/main/java/rx/Completable.java     | 20 +++++++++++++-------
 src/test/java/rx/CompletableTest.java |  2 +-
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 37191e3b12..e9b78c569f 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -1347,7 +1347,7 @@ public final Completable doOnError(Action1<? super Throwable> onError) {
      * @param onSubscribe the consumer called when a CompletableSubscriber subscribes.
      * @param onError the consumer called when this emits an onError event
      * @param onComplete the runnable called just before when this Completable completes normally
-     * @param onAfterComplete the runnable called after this Completable completes normally
+     * @param onAfterTerminate the runnable called after this Completable terminates
      * @param onUnsubscribe the runnable called when the child cancels the subscription
      * @return the new Completable instance
      */
@@ -1355,12 +1355,12 @@ protected final Completable doOnLifecycle(
             final Action1<? super Subscription> onSubscribe,
             final Action1<? super Throwable> onError,
             final Action0 onComplete,
-            final Action0 onAfterComplete,
+            final Action0 onAfterTerminate,
             final Action0 onUnsubscribe) {
         requireNonNull(onSubscribe);
         requireNonNull(onError);
         requireNonNull(onComplete);
-        requireNonNull(onAfterComplete);
+        requireNonNull(onAfterTerminate);
         requireNonNull(onUnsubscribe);
         return create(new OnSubscribe() {
             @Override
@@ -1379,7 +1379,7 @@ public void onCompleted() {
                         s.onCompleted();
 
                         try {
-                            onAfterComplete.call();
+                            onAfterTerminate.call();
                         } catch (Throwable e) {
                             RxJavaHooks.onError(e);
                         }
@@ -1394,6 +1394,12 @@ public void onError(Throwable e) {
                         }
 
                         s.onError(e);
+
+                        try {
+                            onAfterTerminate.call();
+                        } catch (Throwable ex) {
+                            RxJavaHooks.onError(ex);
+                        }
                     }
 
                     @Override
@@ -1455,12 +1461,12 @@ public void call(Throwable e) {
     /**
      * Returns a Completable instance that calls the given onAfterComplete callback after this
      * Completable completes normally.
-     * @param onAfterComplete the callback to call after this Completable emits an onComplete event.
+     * @param onAfterTerminate the callback to call after this Completable emits an onCompleted or onError event.
      * @return the new Completable instance
      * @throws NullPointerException if onAfterComplete is null
      */
-    public final Completable doAfterTerminate(Action0 onAfterComplete) {
-        return doOnLifecycle(Actions.empty(), Actions.empty(), Actions.empty(), onAfterComplete, Actions.empty());
+    public final Completable doAfterTerminate(Action0 onAfterTerminate) {
+        return doOnLifecycle(Actions.empty(), Actions.empty(), Actions.empty(), onAfterTerminate, Actions.empty());
     }
 
     /**
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 72941a7300..98ee57b5b2 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -2058,7 +2058,7 @@ public void call() {
             // expected
         }
 
-        Assert.assertFalse("Closure called", doneAfter.get());
+        Assert.assertTrue("Closure called", doneAfter.get());
     }
 
     @Test(expected = NullPointerException.class)

From aa1c4ed39ee91b65ec8abbfa64b91957fb9ad671 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 12 Nov 2016 19:31:35 +0100
Subject: [PATCH 196/263] 1.x: replace non-serializable value of OnNextValue
 with its toString (#4841)

---
 .../java/rx/exceptions/OnErrorThrowable.java  | 33 +++++++++++----
 .../java/rx/exceptions/OnNextValueTest.java   | 42 +++++++++++++++----
 2 files changed, 59 insertions(+), 16 deletions(-)

diff --git a/src/main/java/rx/exceptions/OnErrorThrowable.java b/src/main/java/rx/exceptions/OnErrorThrowable.java
index 77c255a874..b8c0c3555f 100644
--- a/src/main/java/rx/exceptions/OnErrorThrowable.java
+++ b/src/main/java/rx/exceptions/OnErrorThrowable.java
@@ -15,11 +15,10 @@
  */
 package rx.exceptions;
 
-import java.util.HashSet;
-import java.util.Set;
+import java.io.*;
+import java.util.*;
 
-import rx.plugins.RxJavaErrorHandler;
-import rx.plugins.RxJavaPlugins;
+import rx.plugins.*;
 
 /**
  * Represents a {@code Throwable} that an {@code Observable} might notify its subscribers of, but that then can
@@ -43,7 +42,17 @@ private OnErrorThrowable(Throwable exception) {
     private OnErrorThrowable(Throwable exception, Object value) {
         super(exception);
         hasValue = true;
-        this.value = value;
+        Object v;
+        if (value instanceof Serializable) {
+            v = value;
+        } else {
+            try {
+                v = String.valueOf(value);
+            } catch (Throwable ex) {
+                v = ex.getMessage();
+            }
+        }
+        this.value = v;
     }
 
     /**
@@ -150,7 +159,17 @@ private static Set<Class<?>> create() {
          */
         public OnNextValue(Object value) {
             super("OnError while emitting onNext value: " + renderValue(value));
-            this.value = value;
+            Object v;
+            if (value instanceof Serializable) {
+                v = value;
+            } else {
+                try {
+                    v = String.valueOf(value);
+                } catch (Throwable ex) {
+                    v = ex.getMessage();
+                }
+            }
+            this.value = v;
         }
 
         /**
@@ -177,7 +196,7 @@ public Object getValue() {
          * @return a string version of the object if primitive or managed through error plugin,
          *        otherwise the class name of the object
          */
-        static String renderValue(Object value){
+        static String renderValue(Object value) {
             if (value == null) {
                 return "null";
             }
diff --git a/src/test/java/rx/exceptions/OnNextValueTest.java b/src/test/java/rx/exceptions/OnNextValueTest.java
index 2e36c5bafd..31a37692f8 100644
--- a/src/test/java/rx/exceptions/OnNextValueTest.java
+++ b/src/test/java/rx/exceptions/OnNextValueTest.java
@@ -15,20 +15,16 @@
  */
 package rx.exceptions;
 
+import static org.junit.Assert.*;
+
+import java.io.*;
+
 import org.junit.Test;
 
-import rx.Observable;
-import rx.Observer;
+import rx.*;
 import rx.exceptions.OnErrorThrowable.OnNextValue;
 import rx.functions.Func1;
 
-import java.io.PrintWriter;
-import java.io.StringWriter;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
 /**
  * ```java
  * public OnNextValue(Object value) {
@@ -166,4 +162,32 @@ public void testRenderDouble() {
     public void testRenderVoid() {
         assertEquals("null", OnNextValue.renderValue((Void) null));
     }
+
+    static class Value {
+        @Override
+        public String toString() {
+            return "Value";
+        }
+    }
+
+    @Test
+    public void nonSerializableValue() throws Exception {
+        Throwable e = OnErrorThrowable.addValueAsLastCause(new RuntimeException(), new Value());
+
+        ByteArrayOutputStream bout = new ByteArrayOutputStream();
+        ObjectOutputStream oos = new ObjectOutputStream(bout);
+        oos.writeObject(e);
+        oos.close();
+
+        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
+        ObjectInputStream ois = new ObjectInputStream(bin);
+
+        Throwable f = (Throwable)ois.readObject();
+
+        ois.close();
+
+        Object v = ((OnNextValue)f.getCause()).getValue();
+
+        assertEquals("Value", v);
+    }
 }

From 077c4d0a4fd11612c6c60c1bfc92e339bc25962a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?D=C3=A1vid=20Karnok?= <akarnokd@gmail.com>
Date: Sun, 13 Nov 2016 23:24:34 +0100
Subject: [PATCH 197/263] 1.x: remove ObjectPool, code style cleanups

---
 src/main/java/rx/BackpressureOverflow.java    |  16 +-
 src/main/java/rx/Observable.java              |   4 +-
 src/main/java/rx/Scheduler.java               |  20 +-
 .../rx/exceptions/CompositeException.java     |   6 +-
 .../operators/BufferUntilSubscriber.java      |   2 +-
 .../rx/internal/operators/OnSubscribeAmb.java |   8 +-
 .../operators/OnSubscribeAutoConnect.java     |   2 +-
 .../internal/operators/OnSubscribeRedo.java   |   6 +-
 .../operators/OnSubscribeToMultimap.java      |   2 +-
 .../internal/operators/OperatorGroupBy.java   |   2 +-
 .../internal/operators/OperatorMulticast.java |   2 +-
 .../operators/OperatorOnBackpressureDrop.java |   2 +-
 .../internal/operators/OperatorPublish.java   |   5 +-
 .../rx/internal/operators/OperatorSwitch.java |   2 +-
 .../rx/internal/operators/OperatorTake.java   |   2 +-
 .../schedulers/CachedThreadScheduler.java     |   4 +-
 .../rx/internal/schedulers/SchedulerWhen.java |  22 +-
 .../rx/internal/util/IndexedRingBuffer.java   |  13 +-
 .../java/rx/internal/util/ObjectPool.java     | 163 ---------
 .../java/rx/internal/util/OpenHashSet.java    |   2 +-
 .../java/rx/internal/util/RxRingBuffer.java   |  42 +--
 .../rx/internal/util/SynchronizedQueue.java   | 163 ---------
 .../atomic/AtomicReferenceArrayQueue.java     |   2 +-
 .../util/atomic/BaseLinkedAtomicQueue.java    |   2 +-
 .../util/atomic/MpscLinkedAtomicQueue.java    |   4 +-
 .../util/atomic/SpscAtomicArrayQueue.java     |   4 +-
 .../atomic/SpscExactAtomicArrayQueue.java     |   2 +-
 .../util/atomic/SpscLinkedArrayQueue.java     |   4 +-
 .../atomic/SpscUnboundedAtomicArrayQueue.java |   4 +-
 .../internal/util/unsafe/BaseLinkedQueue.java |   2 +-
 .../unsafe/ConcurrentCircularArrayQueue.java  |   2 +-
 .../internal/util/unsafe/MpscLinkedQueue.java |   6 +-
 .../java/rx/internal/util/unsafe/README.md    |   2 +-
 .../internal/util/unsafe/SpmcArrayQueue.java  |   4 +-
 .../internal/util/unsafe/SpscArrayQueue.java  |   4 +-
 .../util/unsafe/SpscUnboundedArrayQueue.java  |   8 +-
 .../java/rx/observables/SyncOnSubscribe.java  |   4 +-
 src/main/java/rx/schedulers/Schedulers.java   |  42 ++-
 src/perf/java/rx/ScalarJustPerf.java          |   2 +-
 src/perf/java/rx/SingleSourcePerf.java        |   2 +-
 .../rx/jmh/InputWithIncrementingInteger.java  |   2 +-
 .../rx/jmh/PerfAsyncSingleSubscriber.java     |   2 +-
 .../rx/observables/SyncOnSubscribePerf.java   |  10 +-
 src/perf/java/rx/operators/ZipPerf.java       |   8 +-
 src/test/java/rx/BackpressureTests.java       |   4 +-
 .../rx/CapturingUncaughtExceptionHandler.java |   2 +-
 src/test/java/rx/CompletableTest.java         |  14 +-
 src/test/java/rx/NotificationTest.java        |  21 +-
 src/test/java/rx/ObservableTests.java         |   4 +-
 src/test/java/rx/SingleTest.java              |   2 +-
 src/test/java/rx/SubscriberTest.java          |   2 +-
 src/test/java/rx/TestUtil.java                |   4 +-
 .../rx/exceptions/CompositeExceptionTest.java |  18 +-
 .../BlockingOperatorToFutureTest.java         |   8 +-
 .../DeferredScalarSubscriberTest.java         |  10 +-
 .../OnSubscribeCombineLatestTest.java         |   4 +-
 .../operators/OnSubscribeDoOnEachTest.java    |   6 +-
 .../operators/OnSubscribeFromEmitterTest.java |   6 +-
 .../OnSubscribeFromIterableTest.java          |  10 +-
 .../operators/OnSubscribeMapTest.java         |   2 +-
 .../operators/OnSubscribeUsingTest.java       |   4 +-
 .../internal/operators/OperatorAllTest.java   |   4 +-
 .../internal/operators/OperatorAnyTest.java   |   4 +-
 .../operators/OperatorBufferTest.java         |   2 +-
 .../operators/OperatorConcatTest.java         |  31 +-
 .../internal/operators/OperatorDelayTest.java |   8 +-
 .../operators/OperatorGroupByTest.java        |  22 +-
 .../operators/OperatorMaterializeTest.java    |   4 +-
 .../OperatorMergeMaxConcurrentTest.java       |   2 +-
 .../internal/operators/OperatorMergeTest.java |  17 +-
 .../OperatorOnBackpressureBufferTest.java     |   2 +-
 .../OperatorOnBackpressureDropTest.java       |   4 +-
 .../OperatorOnBackpressureLatestTest.java     |   2 +-
 ...ratorOnErrorResumeNextViaFunctionTest.java |   7 +-
 ...torOnErrorResumeNextViaObservableTest.java |  10 +-
 .../operators/OperatorOnErrorReturnTest.java  |   7 +-
 ...nExceptionResumeNextViaObservableTest.java |  16 +-
 .../operators/OperatorPublishTest.java        |   2 +-
 .../internal/operators/OperatorRetryTest.java |  18 +-
 .../OperatorRetryWithPredicateTest.java       |   4 +-
 .../operators/OperatorSerializeTest.java      |  11 +-
 .../internal/operators/OperatorSkipTest.java  |   2 +-
 .../operators/OperatorSkipWhileTest.java      |   5 +-
 .../operators/OperatorSwitchTest.java         |  24 +-
 .../operators/OperatorTakeLastTest.java       |   8 +-
 .../operators/OperatorTakeLastTimedTest.java  |   2 +-
 .../internal/operators/OperatorTakeTest.java  |   2 +-
 .../operators/OperatorTakeUntilTest.java      |   2 +-
 .../operators/OperatorTakeWhileTest.java      |   6 +-
 .../OperatorTimeoutWithSelectorTest.java      |   6 +-
 .../OperatorToObservableSortedListTest.java   |   4 +-
 .../operators/OperatorZipIterableTest.java    |   4 +-
 .../internal/operators/OperatorZipTest.java   |   2 +-
 .../operators/SafeSubscriberTest.java         |   2 +-
 .../operators/SingleOnSubscribeUsingTest.java |   4 +-
 .../producers/SingleDelayedProducerTest.java  |   4 +-
 .../schedulers/NewThreadWorkerTest.java       |   2 +-
 .../internal/util/IndexedRingBufferTest.java  |   2 +-
 .../rx/internal/util/JCToolsQueueTests.java   |   8 +-
 .../internal/util/SynchronizedQueueTest.java  | 155 ---------
 .../rx/observables/AsyncOnSubscribeTest.java  |  79 ++---
 .../observables/BlockingObservableTest.java   |   2 +-
 .../rx/observables/SyncOnSubscribeTest.java   |  29 +-
 .../java/rx/observers/SafeSubscriberTest.java |   6 +-
 .../rx/observers/SerializedObserverTest.java  |   8 +-
 .../java/rx/plugins/RxJavaPluginsTest.java    |   2 +-
 .../AbstractSchedulerConcurrencyTests.java    |   8 +-
 .../rx/schedulers/AbstractSchedulerTests.java |   6 +-
 .../schedulers/ComputationSchedulerTests.java |   2 +-
 .../java/rx/schedulers/SchedulerTests.java    |  20 +-
 .../java/rx/schedulers/SchedulerWhenTest.java | 320 +++++++++---------
 .../schedulers/TrampolineSchedulerTest.java   |   2 +-
 .../subjects/BufferUntilSubscriberTest.java   |  11 +-
 src/test/java/rx/util/AssertObservable.java   |  23 +-
 114 files changed, 607 insertions(+), 1065 deletions(-)
 delete mode 100644 src/main/java/rx/internal/util/ObjectPool.java
 delete mode 100644 src/main/java/rx/internal/util/SynchronizedQueue.java
 delete mode 100644 src/test/java/rx/internal/util/SynchronizedQueueTest.java

diff --git a/src/main/java/rx/BackpressureOverflow.java b/src/main/java/rx/BackpressureOverflow.java
index b47e40f825..39948d8804 100644
--- a/src/main/java/rx/BackpressureOverflow.java
+++ b/src/main/java/rx/BackpressureOverflow.java
@@ -26,6 +26,10 @@
 @Beta
 public final class BackpressureOverflow {
 
+    private BackpressureOverflow() {
+        throw new IllegalStateException("No instances!");
+    }
+
     /**
      * Signal a MissingBackressureException due to lack of requests.
      */
@@ -65,10 +69,10 @@ public interface Strategy {
     /**
      * Drop oldest items from the buffer making room for newer ones.
      */
-    static class DropOldest implements BackpressureOverflow.Strategy {
+    static final class DropOldest implements BackpressureOverflow.Strategy {
         static final DropOldest INSTANCE = new DropOldest();
 
-        private DropOldest() {}
+        private DropOldest() { }
 
         @Override
         public boolean mayAttemptDrop() {
@@ -80,10 +84,10 @@ public boolean mayAttemptDrop() {
      * Drop most recent items, but not {@code onError} nor unsubscribe from source
      * (as {code OperatorOnBackpressureDrop}).
      */
-    static class DropLatest implements BackpressureOverflow.Strategy {
+    static final class DropLatest implements BackpressureOverflow.Strategy {
         static final DropLatest INSTANCE = new DropLatest();
 
-        private DropLatest() {}
+        private DropLatest() { }
 
         @Override
         public boolean mayAttemptDrop() {
@@ -94,11 +98,11 @@ public boolean mayAttemptDrop() {
     /**
      * {@code onError} a MissingBackpressureException and unsubscribe from source.
      */
-    static class Error implements BackpressureOverflow.Strategy {
+    static final class Error implements BackpressureOverflow.Strategy {
 
         static final Error INSTANCE = new Error();
 
-        private Error() {}
+        private Error() { }
 
         @Override
         public boolean mayAttemptDrop() throws MissingBackpressureException {
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 0d25f8f3f2..434cbd22e8 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -3470,7 +3470,7 @@ public static Observable<Integer> range(int start, int count) {
         if (start > Integer.MAX_VALUE - count + 1) {
             throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE");
         }
-        if(count == 1) {
+        if (count == 1) {
             return Observable.just(start);
         }
         return Observable.create(new OnSubscribeRange(start, start + (count - 1)));
@@ -11742,7 +11742,7 @@ public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Intege
      * @return an Observable that emits the items emitted by the source Observable in sorted order
      */
     @Experimental
-    public final Observable<T> sorted(){
+    public final Observable<T> sorted() {
         return toSortedList().flatMapIterable(UtilityFunctions.<List<T>>identity());
     }
 
diff --git a/src/main/java/rx/Scheduler.java b/src/main/java/rx/Scheduler.java
index 9dc789d463..bbcd19ae34 100644
--- a/src/main/java/rx/Scheduler.java
+++ b/src/main/java/rx/Scheduler.java
@@ -212,9 +212,9 @@ public long now() {
      *
      * <pre>
      * Scheduler limitScheduler = Schedulers.computation().when(workers -> {
-     * 	// use merge max concurrent to limit the number of concurrent
-     * 	// callbacks two at a time
-     * 	return Completable.merge(Observable.merge(workers), 2);
+     *     // use merge max concurrent to limit the number of concurrent
+     *     // callbacks two at a time
+     *     return Completable.merge(Observable.merge(workers), 2);
      * });
      * </pre>
      * <p>
@@ -230,9 +230,9 @@ public long now() {
      *
      * <pre>
      * Scheduler limitScheduler = Schedulers.computation().when(workers -> {
-     * 	// use merge max concurrent to limit the number of concurrent
-     * 	// Observables two at a time
-     * 	return Completable.merge(Observable.merge(workers, 2));
+     *     // use merge max concurrent to limit the number of concurrent
+     *     // Observables two at a time
+     *     return Completable.merge(Observable.merge(workers, 2));
      * });
      * </pre>
      *
@@ -243,10 +243,10 @@ public long now() {
      *
      * <pre>
      * Scheduler slowScheduler = Schedulers.computation().when(workers -> {
-     * 	// use concatenate to make each worker happen one at a time.
-     * 	return Completable.concat(workers.map(actions -> {
-     * 		// delay the starting of the next worker by 1 second.
-     * 		return Completable.merge(actions.delaySubscription(1, TimeUnit.SECONDS));
+     *     // use concatenate to make each worker happen one at a time.
+     *     return Completable.concat(workers.map(actions -> {
+     *         // delay the starting of the next worker by 1 second.
+     *         return Completable.merge(actions.delaySubscription(1, TimeUnit.SECONDS));
      *    }));
      * });
      * </pre>
diff --git a/src/main/java/rx/exceptions/CompositeException.java b/src/main/java/rx/exceptions/CompositeException.java
index 8c40d37bb7..cfbfdc2113 100644
--- a/src/main/java/rx/exceptions/CompositeException.java
+++ b/src/main/java/rx/exceptions/CompositeException.java
@@ -141,7 +141,7 @@ public synchronized Throwable getCause() { // NOPMD
 
                 List<Throwable> listOfCauses = getListOfCauses(e);
                 // check if any of them have been seen before
-                for(Throwable child : listOfCauses) {
+                for (Throwable child : listOfCauses) {
                     if (seenCauses.contains(child)) {
                         // already seen this outer Throwable so skip
                         e = new RuntimeException("Duplicate found in causal chain so cropping to prevent loop ...");
@@ -288,7 +288,7 @@ private List<Throwable> getListOfCauses(Throwable ex) {
         if (root == null || root == ex) {
             return list;
         } else {
-            while(true) {
+            while (true) {
                 list.add(root);
                 Throwable cause = root.getCause();
                 if (cause == null || cause == root) {
@@ -311,7 +311,7 @@ private Throwable getRootCause(Throwable e) {
         if (root == null || root == e) {
             return e;
         } else {
-            while(true) {
+            while (true) {
                 Throwable cause = root.getCause();
                 if (cause == null || cause == root) {
                     return root;
diff --git a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
index 2a4401c52c..7855bdc5d9 100644
--- a/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
+++ b/src/main/java/rx/internal/operators/BufferUntilSubscriber.java
@@ -102,7 +102,7 @@ public void call() {
                     }
                 }
                 if (win) {
-                    while(true) {
+                    while (true) {
                         Object o;
                         while ((o = state.buffer.poll()) != null) {
                             NotificationLite.accept(state.get(), o);
diff --git a/src/main/java/rx/internal/operators/OnSubscribeAmb.java b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
index d64567b340..bd0b0fe2b5 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeAmb.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeAmb.java
@@ -29,7 +29,7 @@
  * Given multiple {@link Observable}s, propagates the one that first emits an item.
  * @param <T> the value type
  */
-public final class OnSubscribeAmb<T> implements OnSubscribe<T>{
+public final class OnSubscribeAmb<T> implements OnSubscribe<T> {
     //give default access instead of private as a micro-optimization
     //for access from anonymous classes below
     final Iterable<? extends Observable<? extends T>> sources;
@@ -336,12 +336,12 @@ private boolean isSelected() {
     }
 
     @SuppressWarnings("serial")
-	static final class Selection<T> extends AtomicReference<AmbSubscriber<T>> {
+    static final class Selection<T> extends AtomicReference<AmbSubscriber<T>> {
         final Collection<AmbSubscriber<T>> ambSubscribers = new ConcurrentLinkedQueue<AmbSubscriber<T>>();
 
         public void unsubscribeLosers() {
             AmbSubscriber<T> winner = get();
-            if(winner != null) {
+            if (winner != null) {
                 unsubscribeOthers(winner);
             }
         }
@@ -437,7 +437,7 @@ public void request(long n) {
     }
 
     static <T> void unsubscribeAmbSubscribers(Collection<AmbSubscriber<T>> ambSubscribers) {
-        if(!ambSubscribers.isEmpty()) {
+        if (!ambSubscribers.isEmpty()) {
             for (AmbSubscriber<T> other : ambSubscribers) {
                 other.unsubscribe();
             }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java b/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
index 87a81ae7e8..cf6e7e7473 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeAutoConnect.java
@@ -33,7 +33,7 @@
 public final class OnSubscribeAutoConnect<T> extends AtomicInteger implements OnSubscribe<T> {
     // AtomicInteger aspect of `this` represents the number of clients
 
-	final ConnectableObservable<? extends T> source;
+    final ConnectableObservable<? extends T> source;
     final int numberOfSubscribers;
     final Action1<? super Subscription> connection;
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeRedo.java b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
index 628c58f4ef..fc9fe9e4d2 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRedo.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
@@ -78,12 +78,12 @@ public Observable<?> call(Observable<? extends Notification<?>> ts) {
 
                 @Override
                 public Notification<?> call(Notification<?> terminalNotification) {
-                    if(count == 0) {
+                    if (count == 0) {
                         return terminalNotification;
                     }
 
                     num++;
-                    if(num <= count) {
+                    if (num <= count) {
                         return Notification.createOnNext(num);
                     } else {
                         return terminalNotification;
@@ -153,7 +153,7 @@ public static <T> Observable<T> repeat(Observable<T> source, final long count) {
     }
 
     public static <T> Observable<T> repeat(Observable<T> source, final long count, Scheduler scheduler) {
-        if(count == 0) {
+        if (count == 0) {
             return Observable.empty();
         }
         if (count < 0) {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java b/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
index 6883e93d24..c412ea5af5 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeToMultimap.java
@@ -155,7 +155,7 @@ public void onStart() {
 
         @Override
         public void onNext(T t) {
-            if (done){
+            if (done) {
                 return;
             }
             try {
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index abbe5cf3cf..af2fd4347a 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -43,7 +43,7 @@
  * @param <V>
  *            the value type of the groups
  */
-public final class OperatorGroupBy<T, K, V> implements Operator<GroupedObservable<K, V>, T>{
+public final class OperatorGroupBy<T, K, V> implements Operator<GroupedObservable<K, V>, T> {
     final Func1<? super T, ? extends K> keySelector;
     final Func1<? super T, ? extends V> valueSelector;
     final int bufferSize;
diff --git a/src/main/java/rx/internal/operators/OperatorMulticast.java b/src/main/java/rx/internal/operators/OperatorMulticast.java
index d07f60bf93..3f0777ca91 100644
--- a/src/main/java/rx/internal/operators/OperatorMulticast.java
+++ b/src/main/java/rx/internal/operators/OperatorMulticast.java
@@ -112,7 +112,7 @@ public void call() {
                 guardedSubscription = gs.get();
 
                 // register any subscribers that are waiting with this new subject
-                for(final Subscriber<? super R> s : waitingForConnect) {
+                for (final Subscriber<? super R> s : waitingForConnect) {
                     subject.unsafeSubscribe(new Subscriber<R>(s) {
                         @Override
                         public void onNext(R t) {
diff --git a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
index 6c8770dd04..5ed221746d 100644
--- a/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
+++ b/src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java
@@ -99,7 +99,7 @@ public void onNext(T t) {
                     requested.decrementAndGet();
                 } else {
                     // item dropped
-                    if(onDrop != null) {
+                    if (onDrop != null) {
                         try {
                             onDrop.call(t);
                         } catch (Throwable e) {
diff --git a/src/main/java/rx/internal/operators/OperatorPublish.java b/src/main/java/rx/internal/operators/OperatorPublish.java
index f7879a7ee1..7d087efcb4 100644
--- a/src/main/java/rx/internal/operators/OperatorPublish.java
+++ b/src/main/java/rx/internal/operators/OperatorPublish.java
@@ -21,7 +21,8 @@
 import rx.*;
 import rx.exceptions.*;
 import rx.functions.*;
-import rx.internal.util.*;
+import rx.internal.util.RxRingBuffer;
+import rx.internal.util.atomic.SpscAtomicArrayQueue;
 import rx.internal.util.unsafe.*;
 import rx.observables.ConnectableObservable;
 import rx.subscriptions.Subscriptions;
@@ -244,7 +245,7 @@ static final class PublishSubscriber<T> extends Subscriber<T> implements Subscri
         public PublishSubscriber(AtomicReference<PublishSubscriber<T>> current) {
             this.queue = UnsafeAccess.isUnsafeAvailable()
                     ? new SpscArrayQueue<Object>(RxRingBuffer.SIZE)
-                    : new SynchronizedQueue<Object>(RxRingBuffer.SIZE);
+                    : new SpscAtomicArrayQueue<Object>(RxRingBuffer.SIZE);
 
             this.producers = new AtomicReference<InnerProducer[]>(EMPTY);
             this.current = current;
diff --git a/src/main/java/rx/internal/operators/OperatorSwitch.java b/src/main/java/rx/internal/operators/OperatorSwitch.java
index 1f2806ab53..e50e7cafc9 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitch.java
+++ b/src/main/java/rx/internal/operators/OperatorSwitch.java
@@ -113,7 +113,7 @@ public void call() {
                     clearProducer();
                 }
             }));
-            child.setProducer(new Producer(){
+            child.setProducer(new Producer() {
 
                 @Override
                 public void request(long n) {
diff --git a/src/main/java/rx/internal/operators/OperatorTake.java b/src/main/java/rx/internal/operators/OperatorTake.java
index 7835327ec4..0be75b4f2c 100644
--- a/src/main/java/rx/internal/operators/OperatorTake.java
+++ b/src/main/java/rx/internal/operators/OperatorTake.java
@@ -97,7 +97,7 @@ public void setProducer(final Producer producer) {
 
                     @Override
                     public void request(long n) {
-                        if (n >0 && !completed) {
+                        if (n > 0 && !completed) {
                             // because requests may happen concurrently use a CAS loop to
                             // ensure we only request as much as needed, no more no less
                             while (true) {
diff --git a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
index 940fe685f2..e5728540d5 100644
--- a/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
+++ b/src/main/java/rx/internal/schedulers/CachedThreadScheduler.java
@@ -24,7 +24,7 @@
 import rx.subscriptions.*;
 
 public final class CachedThreadScheduler extends Scheduler implements SchedulerLifecycle {
-    private static final long KEEP_ALIVE_TIME = 60;
+    private static final long KEEP_ALIVE_TIME;
     private static final TimeUnit KEEP_ALIVE_UNIT = TimeUnit.SECONDS;
 
     static final ThreadWorker SHUTDOWN_THREADWORKER;
@@ -41,6 +41,8 @@ public final class CachedThreadScheduler extends Scheduler implements SchedulerL
 
         NONE = new CachedWorkerPool(null, 0, null);
         NONE.shutdown();
+
+        KEEP_ALIVE_TIME = Integer.getInteger("rx.io-scheduler.keepalive", 60);
     }
 
     static final class CachedWorkerPool {
diff --git a/src/main/java/rx/internal/schedulers/SchedulerWhen.java b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
index 1310a96e08..880992c9d5 100644
--- a/src/main/java/rx/internal/schedulers/SchedulerWhen.java
+++ b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
@@ -63,9 +63,9 @@
  *
  * <pre>
  * Scheduler limitScheduler = Schedulers.computation().when(workers -> {
- * 	// use merge max concurrent to limit the number of concurrent
- * 	// callbacks two at a time
- * 	return Completable.merge(Observable.merge(workers), 2);
+ *     // use merge max concurrent to limit the number of concurrent
+ *     // callbacks two at a time
+ *     return Completable.merge(Observable.merge(workers), 2);
  * });
  * </pre>
  * <p>
@@ -81,9 +81,9 @@
  *
  * <pre>
  * Scheduler limitScheduler = Schedulers.computation().when(workers -> {
- * 	// use merge max concurrent to limit the number of concurrent
- * 	// Observables two at a time
- * 	return Completable.merge(Observable.merge(workers, 2));
+ *     // use merge max concurrent to limit the number of concurrent
+ *     // Observables two at a time
+ *     return Completable.merge(Observable.merge(workers, 2));
  * });
  * </pre>
  *
@@ -94,11 +94,11 @@
  *
  * <pre>
  * Scheduler slowScheduler = Schedulers.computation().when(workers -> {
- * 	// use concatenate to make each worker happen one at a time.
- * 	return Completable.concat(workers.map(actions -> {
- * 		// delay the starting of the next worker by 1 second.
- * 		return Completable.merge(actions.delaySubscription(1, TimeUnit.SECONDS));
- * 	}));
+ *     // use concatenate to make each worker happen one at a time.
+ *     return Completable.concat(workers.map(actions -> {
+ *         // delay the starting of the next worker by 1 second.
+ *         return Completable.merge(actions.delaySubscription(1, TimeUnit.SECONDS));
+ *     }));
  * });
  * </pre>
  */
diff --git a/src/main/java/rx/internal/util/IndexedRingBuffer.java b/src/main/java/rx/internal/util/IndexedRingBuffer.java
index 3699fa1d8e..30ba900b7e 100644
--- a/src/main/java/rx/internal/util/IndexedRingBuffer.java
+++ b/src/main/java/rx/internal/util/IndexedRingBuffer.java
@@ -52,15 +52,6 @@ public final class IndexedRingBuffer<E> implements Subscription {
     /* package for unit testing */final AtomicInteger index = new AtomicInteger();
     /* package for unit testing */final AtomicInteger removedIndex = new AtomicInteger();
 
-    private static final ObjectPool<IndexedRingBuffer<?>> POOL = new ObjectPool<IndexedRingBuffer<?>>() {
-
-        @Override
-        protected IndexedRingBuffer<?> createObject() {
-            return new IndexedRingBuffer<Object>();
-        }
-
-    };
-
     /* package for unit testing */static final int SIZE;
 
     // default size of ring buffer
@@ -255,9 +246,8 @@ protected IndexedRingBuffer<?> createObject() {
         SIZE = defaultSize;
     }
 
-    @SuppressWarnings("unchecked")
     public static <T> IndexedRingBuffer<T> getInstance() {
-        return (IndexedRingBuffer<T>) POOL.borrowObject();
+        return new IndexedRingBuffer<T>();
     }
 
     /**
@@ -283,7 +273,6 @@ public void releaseToPool() {
 
         index.set(0);
         removedIndex.set(0);
-        POOL.returnObject(this);
     }
 
     @Override
diff --git a/src/main/java/rx/internal/util/ObjectPool.java b/src/main/java/rx/internal/util/ObjectPool.java
deleted file mode 100644
index 032e1338c3..0000000000
--- a/src/main/java/rx/internal/util/ObjectPool.java
+++ /dev/null
@@ -1,163 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- *
- * 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.
- *
- * Modified from http://www.javacodegeeks.com/2013/08/simple-and-lightweight-pool-implementation.html
- */
-package rx.internal.util;
-
-import java.util.Queue;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicReference;
-
-import rx.internal.schedulers.*;
-import rx.internal.util.unsafe.*;
-import rx.plugins.RxJavaHooks;
-
-public abstract class ObjectPool<T> implements SchedulerLifecycle {
-    Queue<T> pool;
-    final int minSize;
-    final int maxSize;
-    private final long validationInterval;
-
-    private final AtomicReference<Future<?>> periodicTask;
-
-    public ObjectPool() {
-        this(0, 0, 67); // NOPMD
-    }
-
-    /**
-     * Creates the pool.
-     *
-     * @param min
-     *            minimum number of objects residing in the pool
-     * @param max
-     *            maximum number of objects residing in the pool
-     * @param validationInterval
-     *            time in seconds for periodical checking of minIdle / maxIdle conditions in a separate thread.
-     *            When the number of objects is less than minIdle, missing instances will be created.
-     *            When the number of objects is greater than maxIdle, too many instances will be removed.
-     */
-    private ObjectPool(final int min, final int max, final long validationInterval) {
-        this.minSize = min;
-        this.maxSize = max;
-        this.validationInterval = validationInterval;
-        this.periodicTask = new AtomicReference<Future<?>>();
-        // initialize pool
-        initialize(min);
-
-        start();
-    }
-
-    /**
-     * Gets the next free object from the pool. If the pool doesn't contain any objects,
-     * a new object will be created and given to the caller of this method back.
-     *
-     * @return T borrowed object
-     */
-    public T borrowObject() {
-        T object;
-        if ((object = pool.poll()) == null) {
-            object = createObject();
-        }
-
-        return object;
-    }
-
-    /**
-     * Returns object back to the pool.
-     *
-     * @param object
-     *            object to be returned
-     */
-    public void returnObject(T object) {
-        if (object == null) {
-            return;
-        }
-
-        this.pool.offer(object);
-    }
-
-    /**
-     * Shutdown this pool.
-     */
-    @Override
-    public void shutdown() {
-        Future<?> f = periodicTask.getAndSet(null);
-        if (f != null) {
-            f.cancel(false);
-        }
-    }
-
-    @Override
-    public void start() {
-        for (;;) {
-            if (periodicTask.get() != null) {
-                return;
-            }
-            ScheduledExecutorService w = GenericScheduledExecutorService.getInstance();
-
-            Future<?> f;
-            try {
-                f = w.scheduleAtFixedRate(new Runnable() {
-
-                    @Override
-                    public void run() {
-                        int size = pool.size();
-                        if (size < minSize) {
-                            int sizeToBeAdded = maxSize - size;
-                            for (int i = 0; i < sizeToBeAdded; i++) {
-                                pool.add(createObject());
-                            }
-                        } else if (size > maxSize) {
-                            int sizeToBeRemoved = size - maxSize;
-                            for (int i = 0; i < sizeToBeRemoved; i++) {
-                                //                        pool.pollLast();
-                                pool.poll();
-                            }
-                        }
-                    }
-
-                }, validationInterval, validationInterval, TimeUnit.SECONDS);
-            } catch (RejectedExecutionException ex) {
-                RxJavaHooks.onError(ex);
-                break;
-            }
-            if (!periodicTask.compareAndSet(null, f)) {
-                f.cancel(false);
-            } else {
-                break;
-            }
-        }
-    }
-
-    /**
-     * Creates a new object.
-     *
-     * @return T new object
-     */
-    protected abstract T createObject();
-
-    private void initialize(final int min) {
-        if (UnsafeAccess.isUnsafeAvailable()) {
-            pool = new MpmcArrayQueue<T>(Math.max(maxSize, 1024));
-        } else {
-            pool = new ConcurrentLinkedQueue<T>();
-        }
-
-        for (int i = 0; i < min; i++) {
-            pool.add(createObject());
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/rx/internal/util/OpenHashSet.java b/src/main/java/rx/internal/util/OpenHashSet.java
index c5045ace70..238411656f 100644
--- a/src/main/java/rx/internal/util/OpenHashSet.java
+++ b/src/main/java/rx/internal/util/OpenHashSet.java
@@ -173,7 +173,7 @@ void rehash() {
 
 
         for (int j = size; j-- != 0; ) {
-            while (a[--i] == null); // NOPMD
+            while (a[--i] == null) { } // NOPMD
             int pos = mix(a[i].hashCode()) & m;
             if (b[pos] != null) {
                 for (;;) {
diff --git a/src/main/java/rx/internal/util/RxRingBuffer.java b/src/main/java/rx/internal/util/RxRingBuffer.java
index dfbb6cbd6f..366fffd4c2 100644
--- a/src/main/java/rx/internal/util/RxRingBuffer.java
+++ b/src/main/java/rx/internal/util/RxRingBuffer.java
@@ -21,6 +21,7 @@
 import rx.Subscription;
 import rx.exceptions.MissingBackpressureException;
 import rx.internal.operators.NotificationLite;
+import rx.internal.util.atomic.SpscAtomicArrayQueue;
 import rx.internal.util.unsafe.SpmcArrayQueue;
 import rx.internal.util.unsafe.SpscArrayQueue;
 import rx.internal.util.unsafe.UnsafeAccess;
@@ -128,7 +129,6 @@ public class RxRingBuffer implements Subscription {
     private Queue<Object> queue;
 
     private final int size;
-    private final ObjectPool<Queue<Object>> pool;
 
     /**
      * We store the terminal state separately so it doesn't count against the size.
@@ -261,29 +261,9 @@ public class RxRingBuffer implements Subscription {
     }
     public static final int SIZE;
 
-    /* Public so Schedulers can manage the lifecycle of the inner worker. */
-    public static final ObjectPool<Queue<Object>> SPSC_POOL = new ObjectPool<Queue<Object>>() {
-
-        @Override
-        protected SpscArrayQueue<Object> createObject() {
-            return new SpscArrayQueue<Object>(SIZE);
-        }
-
-    };
-
-    /* Public so Schedulers can manage the lifecycle of the inner worker. */
-    public static final ObjectPool<Queue<Object>> SPMC_POOL = new ObjectPool<Queue<Object>>() {
-
-        @Override
-        protected SpmcArrayQueue<Object> createObject() {
-            return new SpmcArrayQueue<Object>(SIZE);
-        }
-
-    };
-
     public static RxRingBuffer getSpscInstance() {
         if (UnsafeAccess.isUnsafeAvailable()) {
-            return new RxRingBuffer(SPSC_POOL, SIZE);
+            return new RxRingBuffer(false, SIZE);
         } else {
             return new RxRingBuffer();
         }
@@ -291,7 +271,7 @@ public static RxRingBuffer getSpscInstance() {
 
     public static RxRingBuffer getSpmcInstance() {
         if (UnsafeAccess.isUnsafeAvailable()) {
-            return new RxRingBuffer(SPMC_POOL, SIZE);
+            return new RxRingBuffer(true, SIZE);
         } else {
             return new RxRingBuffer();
         }
@@ -299,24 +279,16 @@ public static RxRingBuffer getSpmcInstance() {
 
     private RxRingBuffer(Queue<Object> queue, int size) {
         this.queue = queue;
-        this.pool = null;
         this.size = size;
     }
 
-    private RxRingBuffer(ObjectPool<Queue<Object>> pool, int size) {
-        this.pool = pool;
-        this.queue = pool.borrowObject();
+    private RxRingBuffer(boolean spmc, int size) {
+        this.queue = spmc ? new SpmcArrayQueue<Object>(size) : new SpscArrayQueue<Object>(size);
         this.size = size;
     }
 
     public synchronized void release() { // NOPMD
-        Queue<Object> q = queue;
-        ObjectPool<Queue<Object>> p = pool;
-        if (p != null && q != null) {
-            q.clear();
-            queue = null;
-            p.returnObject(q);
-        }
+        // 1.2.3: no longer pooling
     }
 
     @Override
@@ -325,7 +297,7 @@ public void unsubscribe() {
     }
 
     /* package accessible for unit tests */RxRingBuffer() {
-        this(new SynchronizedQueue<Object>(SIZE), SIZE);
+        this(new SpscAtomicArrayQueue<Object>(SIZE), SIZE);
     }
 
     /**
diff --git a/src/main/java/rx/internal/util/SynchronizedQueue.java b/src/main/java/rx/internal/util/SynchronizedQueue.java
deleted file mode 100644
index 27ae5de7f5..0000000000
--- a/src/main/java/rx/internal/util/SynchronizedQueue.java
+++ /dev/null
@@ -1,163 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- *
- * 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 rx.internal.util;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Queue;
-
-/**
- * Intended for use when the `sun.misc.Unsafe` implementations can't be used.
- *
- * @param <T>
- */
-public class SynchronizedQueue<T> implements Queue<T>, Cloneable {
-
-    private final Queue<T> list = new LinkedList<T>();
-    private final int size;
-
-    public SynchronizedQueue() {
-        this.size = -1;
-    }
-
-    public SynchronizedQueue(int size) {
-        this.size = size;
-    }
-
-    @Override
-    public synchronized boolean isEmpty() { // NOPMD
-        return list.isEmpty();
-    }
-
-    @Override
-    public synchronized boolean contains(Object o) { // NOPMD
-        return list.contains(o);
-    }
-
-    @Override
-    public synchronized Iterator<T> iterator() { // NOPMD
-        return list.iterator();
-    }
-
-    @Override
-    public synchronized int size() { // NOPMD
-        return list.size();
-    }
-
-    @Override
-    public synchronized boolean add(T e) { // NOPMD
-        return list.add(e);
-    }
-
-    @Override
-    public synchronized boolean remove(Object o) { // NOPMD
-        return list.remove(o);
-    }
-
-    @Override
-    public synchronized boolean containsAll(Collection<?> c) { // NOPMD
-        return list.containsAll(c);
-    }
-
-    @Override
-    public synchronized boolean addAll(Collection<? extends T> c) { // NOPMD
-        return list.addAll(c);
-    }
-
-    @Override
-    public synchronized boolean removeAll(Collection<?> c) { // NOPMD
-        return list.removeAll(c);
-    }
-
-    @Override
-    public synchronized boolean retainAll(Collection<?> c) { // NOPMD
-        return list.retainAll(c);
-    }
-
-    @Override
-    public synchronized void clear() { // NOPMD
-        list.clear();
-    }
-
-    @Override
-    public synchronized String toString() { // NOPMD
-        return list.toString();
-    }
-
-    @Override
-    public int hashCode() {
-        return list.hashCode();
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj) {
-            return true;
-        }
-        if (obj == null) {
-            return false;
-        }
-        if (getClass() != obj.getClass()) {
-            return false;
-        }
-        SynchronizedQueue<?> other = (SynchronizedQueue<?>) obj;
-        return list.equals(other.list);
-    }
-
-    @Override
-    public synchronized T peek() { // NOPMD
-        return list.peek();
-    }
-
-    @Override
-    public synchronized T element() { // NOPMD
-        return list.element();
-    }
-
-    @Override
-    public synchronized T poll() { // NOPMD
-        return list.poll();
-    }
-
-    @Override
-    public synchronized T remove() { // NOPMD
-        return list.remove();
-    }
-
-    @Override
-    public synchronized boolean offer(T e) { // NOPMD
-        return !(size > -1 && list.size() + 1 > size) && list.offer(e);
-    }
-
-    @Override
-    public synchronized Object clone() { // NOPMD
-        SynchronizedQueue<T> q = new SynchronizedQueue<T>(size);
-        q.addAll(list);
-        return q;
-    }
-
-    @Override
-    public synchronized Object[] toArray() { // NOPMD
-        return list.toArray();
-    }
-
-    @Override
-    public synchronized <R> R[] toArray(R[] a) { // NOPMD
-        return list.toArray(a);
-    }
-
-}
diff --git a/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java b/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java
index 8a167f0c72..24691ca832 100644
--- a/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/AtomicReferenceArrayQueue.java
@@ -36,7 +36,7 @@ public Iterator<E> iterator() {
     @Override
     public void clear() {
         // we have to test isEmpty because of the weaker poll() guarantee
-        while (poll() != null || !isEmpty()) ; // NOPMD
+        while (poll() != null || !isEmpty()) { } // NOPMD
     }
     protected final int calcElementOffset(long index, int mask) {
         return (int)index & mask;
diff --git a/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java b/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
index 81c12fc645..64e5bd9c49 100644
--- a/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
+++ b/src/main/java/rx/internal/util/atomic/BaseLinkedAtomicQueue.java
@@ -70,7 +70,7 @@ public final int size() {
         // must chase the nodes all the way to the producer node, but there's no need to chase a moving target.
         while (chaserNode != producerNode && size < Integer.MAX_VALUE) {
             LinkedQueueNode<E> next;
-            while((next = chaserNode.lvNext()) == null); // NOPMD
+            while ((next = chaserNode.lvNext()) == null) { } // NOPMD
             chaserNode = next;
             size++;
         }
diff --git a/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java b/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
index 6831cbe923..54c4bbd1aa 100644
--- a/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
+++ b/src/main/java/rx/internal/util/atomic/MpscLinkedAtomicQueue.java
@@ -94,7 +94,7 @@ public E poll() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD
+            while ((nextNode = currConsumerNode.lvNext()) == null) { } // NOPMD
             // got the next node...
 
             // we have to null out the value because we are going to hang on to the node
@@ -114,7 +114,7 @@ public E peek() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD
+            while ((nextNode = currConsumerNode.lvNext()) == null) { } // NOPMD
             // got the next node...
             return nextNode.lpValue();
         }
diff --git a/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
index 3cd0b0e81f..5bf922346c 100644
--- a/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscAtomicArrayQueue.java
@@ -57,10 +57,10 @@ public boolean offer(E e) {
         final int offset = calcElementOffset(index, mask);
         if (index >= producerLookAhead) {
             int step = lookAheadStep;
-            if (null == lvElement(buffer, calcElementOffset(index + step, mask))) {// LoadLoad
+            if (null == lvElement(buffer, calcElementOffset(index + step, mask))) { // LoadLoad
                 producerLookAhead = index + step;
             }
-            else if (null != lvElement(buffer, offset)){
+            else if (null != lvElement(buffer, offset)) {
                 return false;
             }
         }
diff --git a/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
index 9e9affe472..b3f71e264c 100644
--- a/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscExactAtomicArrayQueue.java
@@ -82,7 +82,7 @@ public T peek() {
     }
     @Override
     public void clear() {
-        while (poll() != null || !isEmpty()); // NOPMD
+        while (poll() != null || !isEmpty()) { } // NOPMD
     }
     @Override
     public boolean isEmpty() {
diff --git a/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
index c2b4f43eac..a796e1c373 100644
--- a/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscLinkedArrayQueue.java
@@ -78,7 +78,7 @@ public boolean offer(final T e) {
             final int lookAheadStep = producerLookAheadStep;
             // go around the buffer or resize if full (unless we hit max capacity)
             int lookAheadElementOffset = calcWrappedOffset(index + lookAheadStep, mask);
-            if (null == lvElement(buffer, lookAheadElementOffset)) {// LoadLoad
+            if (null == lvElement(buffer, lookAheadElementOffset)) { // LoadLoad
                 producerLookAhead = index + lookAheadStep - 1; // joy, there's plenty of room
                 return writeToQueue(buffer, e, index, offset);
             } else if (null == lvElement(buffer, calcWrappedOffset(index + 1, mask))) { // buffer is not full
@@ -178,7 +178,7 @@ public T peek() {
 
     @Override
     public void clear() {
-        while (poll() != null || !isEmpty()); // NOPMD
+        while (poll() != null || !isEmpty()) { } // NOPMD
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java b/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
index 9468173869..87bf5afc9a 100644
--- a/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
+++ b/src/main/java/rx/internal/util/atomic/SpscUnboundedAtomicArrayQueue.java
@@ -78,7 +78,7 @@ public boolean offer(final T e) {
             final int lookAheadStep = producerLookAheadStep;
             // go around the buffer or resize if full (unless we hit max capacity)
             int lookAheadElementOffset = calcWrappedOffset(index + lookAheadStep, mask);
-            if (null == lvElement(buffer, lookAheadElementOffset)) {// LoadLoad
+            if (null == lvElement(buffer, lookAheadElementOffset)) { // LoadLoad
                 producerLookAhead = index + lookAheadStep - 1; // joy, there's plenty of room
                 return writeToQueue(buffer, e, index, offset);
             } else if (null != lvElement(buffer, calcWrappedOffset(index + 1, mask))) { // buffer is not full
@@ -178,7 +178,7 @@ public T peek() {
 
     @Override
     public void clear() {
-        while (poll() != null || !isEmpty()); // NOPMD
+        while (poll() != null || !isEmpty()) { } // NOPMD
     }
 
     @SuppressWarnings("unchecked")
diff --git a/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java b/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
index f2d80eb6c5..cdc5ed93d3 100644
--- a/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/BaseLinkedQueue.java
@@ -106,7 +106,7 @@ public final int size() {
         // must chase the nodes all the way to the producer node, but there's no need to chase a moving target.
         while (chaserNode != producerNode && size < Integer.MAX_VALUE) {
             LinkedQueueNode<E> next;
-            while((next = chaserNode.lvNext()) == null); // NOPMD
+            while ((next = chaserNode.lvNext()) == null) { } // NOPMD
             chaserNode = next;
             size++;
         }
diff --git a/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java b/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
index 7a11f99d85..08456f0b0e 100644
--- a/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/ConcurrentCircularArrayQueue.java
@@ -182,6 +182,6 @@ public Iterator<E> iterator() {
     @Override
     public void clear() {
         // we have to test isEmpty because of the weaker poll() guarantee
-        while (poll() != null || !isEmpty()) ; // NOPMD
+        while (poll() != null || !isEmpty()) { } // NOPMD
     }
 }
diff --git a/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java b/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
index e6b4c350e9..b69a5a0daa 100644
--- a/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/MpscLinkedQueue.java
@@ -49,7 +49,7 @@ protected LinkedQueueNode<E> xchgProducerNode(LinkedQueueNode<E> newVal) {
         Object oldVal;
         do {
             oldVal = producerNode;
-        } while(!UNSAFE.compareAndSwapObject(this, P_NODE_OFFSET, oldVal, newVal));
+        } while (!UNSAFE.compareAndSwapObject(this, P_NODE_OFFSET, oldVal, newVal));
         return (LinkedQueueNode<E>) oldVal;
     }
 
@@ -110,7 +110,7 @@ public E poll() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD
+            while ((nextNode = currConsumerNode.lvNext()) == null) { } // NOPMD
             // got the next node...
 
             // we have to null out the value because we are going to hang on to the node
@@ -130,7 +130,7 @@ public E peek() {
         }
         else if (currConsumerNode != lvProducerNode()) {
             // spin, we are no longer wait free
-            while((nextNode = currConsumerNode.lvNext()) == null); // NOPMD
+            while ((nextNode = currConsumerNode.lvNext()) == null) { } // NOPMD
             // got the next node...
             return nextNode.lpValue();
         }
diff --git a/src/main/java/rx/internal/util/unsafe/README.md b/src/main/java/rx/internal/util/unsafe/README.md
index 1bff119cd7..c847ea77e5 100644
--- a/src/main/java/rx/internal/util/unsafe/README.md
+++ b/src/main/java/rx/internal/util/unsafe/README.md
@@ -2,7 +2,7 @@ This package contains code that relies on sun.misc.Unsafe. Before using it you M
 
 Much of the code in this package comes from or is inspired by the JCTools project: https://github.com/JCTools/JCTools
 
-JCTools has now published artifacts (https://github.com/JCTools/JCTools/issues/17) so RxJava could add JCTools as a "shadow" dependency (https://github.com/ReactiveX/RxJava/issues/1735). 
+JCTools has now published artifacts (https://github.com/JCTools/JCTools/issues/17) so RxJava could add JCTools as a "shadow" dependency (https://github.com/ReactiveX/RxJava/issues/1735).
 RxJava has a "zero dependency" policy for the core library, so if we do add it as a dependency, it won't be an externally visible dependency that results in a separate jar.
 
 The license for the JCTools code is https://github.com/JCTools/JCTools/blob/master/LICENSE
diff --git a/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
index 325bfd6eae..043511cac8 100644
--- a/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpmcArrayQueue.java
@@ -130,12 +130,12 @@ public boolean offer(final E e) {
         if (null != lvElement(lb, offset)) {
             long size = currProducerIndex - lvConsumerIndex();
 
-            if(size > lMask) {
+            if (size > lMask) {
                 return false;
             }
             else {
                 // spin wait for slot to clear, buggers wait freedom
-                while(null != lvElement(lb, offset)); // NOPMD
+                while (null != lvElement(lb, offset)) { } // NOPMD
             }
         }
         spElement(lb, offset, e);
diff --git a/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
index 15c9a9d06f..f5bab6f124 100644
--- a/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpscArrayQueue.java
@@ -25,7 +25,7 @@ abstract class SpscArrayQueueColdField<E> extends ConcurrentCircularArrayQueue<E
     protected final int lookAheadStep;
     public SpscArrayQueueColdField(int capacity) {
         super(capacity);
-        lookAheadStep = Math.min(capacity/4, MAX_LOOK_AHEAD_STEP);
+        lookAheadStep = Math.min(capacity / 4, MAX_LOOK_AHEAD_STEP);
     }
 }
 abstract class SpscArrayQueueL1Pad<E> extends SpscArrayQueueColdField<E> {
@@ -112,7 +112,7 @@ public boolean offer(final E e) {
         final E[] lElementBuffer = buffer;
         final long index = producerIndex;
         final long offset = calcElementOffset(index);
-        if (null != lvElement(lElementBuffer, offset)){
+        if (null != lvElement(lElementBuffer, offset)) {
             return false;
         }
         soElement(lElementBuffer, offset, e); // StoreStore
diff --git a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
index eab0fec910..aa7baed670 100644
--- a/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
+++ b/src/main/java/rx/internal/util/unsafe/SpscUnboundedArrayQueue.java
@@ -50,7 +50,7 @@ abstract class SpscUnboundedArrayQueueConsumerField<E> extends SpscUnboundedArra
 
 @SuppressAnimalSniffer
 public class SpscUnboundedArrayQueue<E> extends SpscUnboundedArrayQueueConsumerField<E>
-    implements QueueProgressIndicators{
+    implements QueueProgressIndicators {
     static final int MAX_LOOK_AHEAD_STEP = Integer.getInteger("jctools.spsc.max.lookahead.step", 4096);
     private final static long P_INDEX_OFFSET;
     private final static long C_INDEX_OFFSET;
@@ -126,7 +126,7 @@ public final boolean offer(final E e) {
             final int lookAheadStep = producerLookAheadStep;
             // go around the buffer or resize if full (unless we hit max capacity)
             long lookAheadElementOffset = calcWrappedOffset(index + lookAheadStep, mask);
-            if (null == lvElement(buffer, lookAheadElementOffset)) {// LoadLoad
+            if (null == lvElement(buffer, lookAheadElementOffset)) { // LoadLoad
                 producerLookAhead = index + lookAheadStep - 1; // joy, there's plenty of room
                 return writeToQueue(buffer, e, index, offset);
             } else if (null != lvElement(buffer, calcWrappedOffset(index + 1, mask))) { // buffer is not full
@@ -159,11 +159,11 @@ private void resize(final E[] oldBuffer, final long currIndex, final long offset
     }
 
     private void soNext(E[] curr, E[] next) {
-        soElement(curr, calcDirectOffset(curr.length -1), next);
+        soElement(curr, calcDirectOffset(curr.length - 1), next);
     }
     @SuppressWarnings("unchecked")
     private E[] lvNext(E[] curr) {
-        return (E[]) lvElement(curr, calcDirectOffset(curr.length -1));
+        return (E[]) lvElement(curr, calcDirectOffset(curr.length - 1));
     }
     /**
      * {@inheritDoc}
diff --git a/src/main/java/rx/observables/SyncOnSubscribe.java b/src/main/java/rx/observables/SyncOnSubscribe.java
index 6e4b887da4..dc9e2a7a3c 100644
--- a/src/main/java/rx/observables/SyncOnSubscribe.java
+++ b/src/main/java/rx/observables/SyncOnSubscribe.java
@@ -261,7 +261,7 @@ public Void call(Void state, Observer<? super T> subscriber) {
                 return null;
             }
         };
-        Action1<? super Void> wrappedOnUnsubscribe = new Action1<Void>(){
+        Action1<? super Void> wrappedOnUnsubscribe = new Action1<Void>() {
             @Override
             public void call(Void t) {
                 onUnsubscribe.call();
@@ -350,7 +350,7 @@ public boolean isUnsubscribed() {
 
         @Override
         public void unsubscribe() {
-            while(true) {
+            while (true) {
                 long requestCount = get();
                 if (compareAndSet(0L, -1L)) {
                     doUnsubscribe();
diff --git a/src/main/java/rx/schedulers/Schedulers.java b/src/main/java/rx/schedulers/Schedulers.java
index 502a59bcf7..e6435965e5 100644
--- a/src/main/java/rx/schedulers/Schedulers.java
+++ b/src/main/java/rx/schedulers/Schedulers.java
@@ -15,19 +15,39 @@
  */
 package rx.schedulers;
 
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicReference;
+
 import rx.Scheduler;
 import rx.annotations.Experimental;
-import rx.internal.schedulers.ExecutorScheduler;
-import rx.internal.schedulers.GenericScheduledExecutorService;
-import rx.internal.schedulers.SchedulerLifecycle;
-import rx.internal.util.RxRingBuffer;
+import rx.internal.schedulers.*;
 import rx.plugins.*;
 
-import java.util.concurrent.Executor;
-import java.util.concurrent.atomic.AtomicReference;
-
 /**
  * Static factory methods for creating Schedulers.
+ * <p>
+ * System configuration properties:
+ * <table border='1'>
+ * <tr><td>Property name</td><td>Description</td><td>Default</td></tr>
+ * <tr>
+ * <td>{@code rx.io-scheduler.keepalive}</td><td>time (in seconds) to keep an unused backing
+ *     thread-pool</td><td>60</td>
+ * </tr>
+ * <tr>
+ * <td>{@code rx.scheduler.max-computation-threads}</td><td>number of threads the
+ *     computation scheduler uses (between 1 and number of available processors)</td><td>
+ *     number of available processors.</td>
+ * </tr>
+ * <tr>
+ * <td>{@code rx.scheduler.jdk6.purge-frequency-millis}</td><td>time (in milliseconds) between calling
+ *     purge on any active backing thread-pool on a Java 6 runtime</td><td>1000</td>
+ * </tr>
+ * <tr>
+ * <td>{@code rx.scheduler.jdk6.purge-force}</td><td> boolean forcing the call to purge on any active
+ *     backing thread-pool</td><td>false</td>
+ * </tr>
+ * </ul>
+ * </table>
  */
 public final class Schedulers {
 
@@ -185,10 +205,6 @@ public static void start() {
 
         synchronized (s) {
             GenericScheduledExecutorService.INSTANCE.start();
-
-            RxRingBuffer.SPSC_POOL.start();
-
-            RxRingBuffer.SPMC_POOL.start();
         }
     }
     /**
@@ -201,10 +217,6 @@ public static void shutdown() {
 
         synchronized (s) {
             GenericScheduledExecutorService.INSTANCE.shutdown();
-
-            RxRingBuffer.SPSC_POOL.shutdown();
-
-            RxRingBuffer.SPMC_POOL.shutdown();
         }
     }
 
diff --git a/src/perf/java/rx/ScalarJustPerf.java b/src/perf/java/rx/ScalarJustPerf.java
index 548d1764fd..c50f945672 100644
--- a/src/perf/java/rx/ScalarJustPerf.java
+++ b/src/perf/java/rx/ScalarJustPerf.java
@@ -126,7 +126,7 @@ void runAsync(Blackhole bh, Observable<Integer> source) {
 
         source.subscribe(lo);
 
-        while (lo.latch.getCount() != 0L);
+        while (lo.latch.getCount() != 0L) { }
     }
 
     @Benchmark
diff --git a/src/perf/java/rx/SingleSourcePerf.java b/src/perf/java/rx/SingleSourcePerf.java
index c735e4e2b0..743d8669fb 100644
--- a/src/perf/java/rx/SingleSourcePerf.java
+++ b/src/perf/java/rx/SingleSourcePerf.java
@@ -169,7 +169,7 @@ public void await() {
         }
 
         public void awaitSpin() {
-            while (cdl.getCount() != 0L) ;
+            while (cdl.getCount() != 0L) { }
         }
     }
 
diff --git a/src/perf/java/rx/jmh/InputWithIncrementingInteger.java b/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
index ad0c350c2d..9700db74c1 100644
--- a/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
+++ b/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
@@ -59,7 +59,7 @@ public void call(Subscriber<? super Integer> s) {
             @Override
             public Iterator<Integer> iterator() {
                 return new Iterator<Integer>() {
-                    int i = 0;
+                    int i;
 
                     @Override
                     public boolean hasNext() {
diff --git a/src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java b/src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java
index 01d7600d6f..0a579c3087 100644
--- a/src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java
+++ b/src/perf/java/rx/jmh/PerfAsyncSingleSubscriber.java
@@ -64,6 +64,6 @@ public void sleepAwait() {
      * Spins until the subscriber receives an events.
      */
     public void spinAwait() {
-        while (cdl.getCount() != 0) ;
+        while (cdl.getCount() != 0) { }
     }
 }
diff --git a/src/perf/java/rx/observables/SyncOnSubscribePerf.java b/src/perf/java/rx/observables/SyncOnSubscribePerf.java
index 54377e433b..23c36e3d6b 100644
--- a/src/perf/java/rx/observables/SyncOnSubscribePerf.java
+++ b/src/perf/java/rx/observables/SyncOnSubscribePerf.java
@@ -49,7 +49,7 @@ private static Blackhole _jmh_tryInit_() {
     }
 
     private static OnSubscribe<Integer> createSyncOnSubscribe(final Iterator<Integer> iterator) {
-        return new SyncOnSubscribe<Void, Integer>(){
+        return new SyncOnSubscribe<Void, Integer>() {
 
             @Override
             protected Void generateState() {
@@ -60,12 +60,12 @@ protected Void generateState() {
             protected Void next(Void state, Observer<? super Integer> observer) {
                 if (iterator.hasNext()) {
                     observer.onNext(iterator.next());
-                }
-                else
+                } else {
                     observer.onCompleted();
-                return null;
                 }
-            };
+                return null;
+            }
+        };
     }
 
 //    @Benchmark
diff --git a/src/perf/java/rx/operators/ZipPerf.java b/src/perf/java/rx/operators/ZipPerf.java
index 36608aea53..1591c8e8d6 100644
--- a/src/perf/java/rx/operators/ZipPerf.java
+++ b/src/perf/java/rx/operators/ZipPerf.java
@@ -67,7 +67,7 @@ public void setup() {
         Integer[] array2 = new Integer[secondLen];
         Arrays.fill(array2, 777);
 
-        baseline = Observable.from(firstLen < secondLen? array2 : array1);
+        baseline = Observable.from(firstLen < secondLen ? array2 : array1);
 
         Observable<Integer> o1 = Observable.from(array1);
 
@@ -107,7 +107,7 @@ public void syncAsync(Blackhole bh) throws Exception {
         firstSync.subscribe(o);
 
         if (small) {
-            while (o.latch.getCount() != 0);
+            while (o.latch.getCount() != 0) { }
         } else {
             o.latch.await();
         }
@@ -119,7 +119,7 @@ public void asyncSync(Blackhole bh) throws Exception {
         secondSync.subscribe(o);
 
         if (small) {
-            while (o.latch.getCount() != 0);
+            while (o.latch.getCount() != 0) { }
         } else {
             o.latch.await();
         }
@@ -131,7 +131,7 @@ public void asyncAsync(Blackhole bh) throws Exception {
         bothAsync.subscribe(o);
 
         if (small) {
-            while (o.latch.getCount() != 0);
+            while (o.latch.getCount() != 0) { }
         } else {
             o.latch.await();
         }
diff --git a/src/test/java/rx/BackpressureTests.java b/src/test/java/rx/BackpressureTests.java
index 9556aff5e6..f9931f8754 100644
--- a/src/test/java/rx/BackpressureTests.java
+++ b/src/test/java/rx/BackpressureTests.java
@@ -600,7 +600,7 @@ private static Observable<Integer> incrementingIntegers(final AtomicInteger coun
             @Override
             public void call(final Subscriber<? super Integer> s) {
                 s.setProducer(new Producer() {
-                    int i = 0;
+                    int i;
 
                     @Override
                     public void request(long n) {
@@ -639,7 +639,7 @@ public void request(long n) {
     private static Observable<Integer> firehose(final AtomicInteger counter) {
         return Observable.create(new OnSubscribe<Integer>() {
 
-            int i = 0;
+            int i;
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
diff --git a/src/test/java/rx/CapturingUncaughtExceptionHandler.java b/src/test/java/rx/CapturingUncaughtExceptionHandler.java
index a44c6df080..27709943b8 100644
--- a/src/test/java/rx/CapturingUncaughtExceptionHandler.java
+++ b/src/test/java/rx/CapturingUncaughtExceptionHandler.java
@@ -19,7 +19,7 @@
 import java.util.concurrent.CountDownLatch;
 
 public final class CapturingUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
-    public int count = 0;
+    public int count;
     public Throwable caught;
     public CountDownLatch completed = new CountDownLatch(1);
 
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 98ee57b5b2..97a40439c8 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -2606,7 +2606,7 @@ public void call(Throwable e) {
     public void subscribeTwoCallbacksFirstNull() {
         normal.completable.subscribe(null, new Action1<Throwable>() {
             @Override
-            public void call(Throwable throwable) {}
+            public void call(Throwable throwable) { }
         });
     }
 
@@ -2894,9 +2894,9 @@ public Observable<Object> call(Completable c) {
             }
         });
 
-        flow.toBlocking().forEach(new Action1<Object>(){
+        flow.toBlocking().forEach(new Action1<Object>() {
             @Override
-            public void call(Object e){ }
+            public void call(Object e) { }
         });
     }
 
@@ -3887,8 +3887,12 @@ private static void expectUncaughtTestException(Action0 action) {
             assertEquals("Should have received exactly 1 exception", 1, handler.count);
             Throwable caught = handler.caught;
             while (caught != null) {
-                if (caught instanceof TestException) break;
-                if (caught == caught.getCause()) break;
+                if (caught instanceof TestException) {
+                    break;
+                }
+                if (caught == caught.getCause()) {
+                    break;
+                }
                 caught = caught.getCause();
             }
             assertTrue("A TestException should have been delivered to the handler",
diff --git a/src/test/java/rx/NotificationTest.java b/src/test/java/rx/NotificationTest.java
index df79092ff4..c25e28d136 100644
--- a/src/test/java/rx/NotificationTest.java
+++ b/src/test/java/rx/NotificationTest.java
@@ -29,49 +29,49 @@
 public class NotificationTest {
 
     @Test
-    public void testOnNextIntegerNotificationDoesNotEqualNullNotification(){
+    public void testOnNextIntegerNotificationDoesNotEqualNullNotification() {
         final Notification<Integer> integerNotification = Notification.createOnNext(1);
         final Notification<Integer> nullNotification = Notification.createOnNext(null);
         assertFalse(integerNotification.equals(nullNotification));
     }
 
     @Test
-    public void testOnNextNullNotificationDoesNotEqualIntegerNotification(){
+    public void testOnNextNullNotificationDoesNotEqualIntegerNotification() {
         final Notification<Integer> integerNotification = Notification.createOnNext(1);
         final Notification<Integer> nullNotification = Notification.createOnNext(null);
         assertFalse(nullNotification.equals(integerNotification));
     }
 
     @Test
-    public void testOnNextIntegerNotificationsWhenEqual(){
+    public void testOnNextIntegerNotificationsWhenEqual() {
         final Notification<Integer> integerNotification = Notification.createOnNext(1);
         final Notification<Integer> integerNotification2 = Notification.createOnNext(1);
         assertTrue(integerNotification.equals(integerNotification2));
     }
 
     @Test
-    public void testOnNextIntegerNotificationsWhenNotEqual(){
+    public void testOnNextIntegerNotificationsWhenNotEqual() {
         final Notification<Integer> integerNotification = Notification.createOnNext(1);
         final Notification<Integer> integerNotification2 = Notification.createOnNext(2);
         assertFalse(integerNotification.equals(integerNotification2));
     }
 
     @Test
-    public void testOnErrorIntegerNotificationDoesNotEqualNullNotification(){
+    public void testOnErrorIntegerNotificationDoesNotEqualNullNotification() {
         final Notification<Integer> integerNotification = Notification.createOnError(new Exception());
         final Notification<Integer> nullNotification = Notification.createOnError(null);
         assertFalse(integerNotification.equals(nullNotification));
     }
 
     @Test
-    public void testOnErrorNullNotificationDoesNotEqualIntegerNotification(){
+    public void testOnErrorNullNotificationDoesNotEqualIntegerNotification() {
         final Notification<Integer> integerNotification = Notification.createOnError(new Exception());
         final Notification<Integer> nullNotification = Notification.createOnError(null);
         assertFalse(nullNotification.equals(integerNotification));
     }
 
     @Test
-    public void testOnErrorIntegerNotificationsWhenEqual(){
+    public void testOnErrorIntegerNotificationsWhenEqual() {
         final Exception exception = new Exception();
         final Notification<Integer> onErrorNotification = Notification.createOnError(exception);
         final Notification<Integer> onErrorNotification2 = Notification.createOnError(exception);
@@ -79,7 +79,7 @@ public void testOnErrorIntegerNotificationsWhenEqual(){
     }
 
     @Test
-    public void testOnErrorIntegerNotificationWhenNotEqual(){
+    public void testOnErrorIntegerNotificationWhenNotEqual() {
         final Notification<Integer> onErrorNotification = Notification.createOnError(new Exception());
         final Notification<Integer> onErrorNotification2 = Notification.createOnError(new Exception());
         assertFalse(onErrorNotification.equals(onErrorNotification2));
@@ -256,5 +256,10 @@ public boolean equals(Object o) {
             }
             return false;
         }
+
+        @Override
+        public int hashCode() {
+            return getMessage().hashCode();
+        }
     }
 }
diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
index 433d56331b..bed04b4cdc 100644
--- a/src/test/java/rx/ObservableTests.java
+++ b/src/test/java/rx/ObservableTests.java
@@ -1089,7 +1089,7 @@ public void testSubscribingSubscriberAsObserverMaintainsSubscriptionChain() {
         subscriber.assertUnsubscribed();
     }
 
-    @Test(expected=OnErrorNotImplementedException.class)
+    @Test(expected = OnErrorNotImplementedException.class)
     public void testForEachWithError() {
         Observable.error(new Exception("boo"))
         //
@@ -1100,7 +1100,7 @@ public void call(Object t) {
             }});
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test(expected = IllegalArgumentException.class)
     public void testForEachWithNull() {
         Observable.error(new Exception("boo"))
         //
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index 41b75e73f7..eefcde2699 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -2055,7 +2055,7 @@ public Single<Integer> call(Integer v) {
         })
         .subscribe();
 
-        while (!ps.hasObservers() && !Thread.currentThread().isInterrupted()) ;
+        while (!ps.hasObservers() && !Thread.currentThread().isInterrupted()) { }
 
         s.unsubscribe();
 
diff --git a/src/test/java/rx/SubscriberTest.java b/src/test/java/rx/SubscriberTest.java
index 82abd5fee6..5180966a1a 100644
--- a/src/test/java/rx/SubscriberTest.java
+++ b/src/test/java/rx/SubscriberTest.java
@@ -489,7 +489,7 @@ public void testOnStartRequestsAreAdditiveAndOverflowBecomesMaxValue() {
             @Override
             public void onStart() {
                 request(2);
-                request(Long.MAX_VALUE-1);
+                request(Long.MAX_VALUE - 1);
             }
 
             @Override
diff --git a/src/test/java/rx/TestUtil.java b/src/test/java/rx/TestUtil.java
index 7beb6d0f4a..15414b510e 100644
--- a/src/test/java/rx/TestUtil.java
+++ b/src/test/java/rx/TestUtil.java
@@ -67,7 +67,7 @@ public static void race(Action0 r1, final Action0 r2) {
                 @Override
                 public void call() {
                     if (counter.decrementAndGet() != 0) {
-                        while (counter.get() != 0);
+                        while (counter.get() != 0) { }
                     }
 
                     try {
@@ -81,7 +81,7 @@ public void call() {
             });
 
             if (counter.decrementAndGet() != 0) {
-                while (counter.get() != 0);
+                while (counter.get() != 0) { }
             }
 
             try {
diff --git a/src/test/java/rx/exceptions/CompositeExceptionTest.java b/src/test/java/rx/exceptions/CompositeExceptionTest.java
index 5451a8cf10..e7f33251c5 100644
--- a/src/test/java/rx/exceptions/CompositeExceptionTest.java
+++ b/src/test/java/rx/exceptions/CompositeExceptionTest.java
@@ -15,18 +15,12 @@
  */
 package rx.exceptions;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.*;
 
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
+import java.io.*;
+import java.util.*;
 
-import org.junit.Test;
+import org.junit.*;
 
 import rx.exceptions.CompositeException.CompositeExceptionCausalChain;
 
@@ -159,7 +153,7 @@ private static Throwable getRootCause(Throwable ex) {
         if (root == null) {
             return null;
         } else {
-            while(true) {
+            while (true) {
                 if (root.getCause() == null) {
                     return root;
                 } else {
@@ -257,7 +251,7 @@ public void complexCauses() {
         e5.initCause(e6);
 
         CompositeException compositeException = new CompositeException(e1, e3, e5);
-        assert(compositeException.getCause() instanceof CompositeExceptionCausalChain);
+        Assert.assertTrue(compositeException.getCause() instanceof CompositeExceptionCausalChain);
 
         List<Throwable> causeChain = new ArrayList<Throwable>();
         Throwable cause = compositeException.getCause().getCause();
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java b/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
index 5a85995d7b..97d8cdb250 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
@@ -58,7 +58,7 @@ public void testExceptionWithMoreThanOneElement() throws Throwable {
             // we expect an exception since there are more than 1 element
             f.get();
         }
-        catch(ExecutionException e) {
+        catch (ExecutionException e) {
             throw e.getCause();
         }
     }
@@ -83,7 +83,7 @@ public void call(Subscriber<? super String> observer) {
         }
     }
 
-    @Test(expected=CancellationException.class)
+    @Test(expected = CancellationException.class)
     public void testGetAfterCancel() throws Exception {
         Observable<String> obs = Observable.create(new OperationNeverComplete<String>());
         Future<String> f = toFuture(obs);
@@ -92,7 +92,7 @@ public void testGetAfterCancel() throws Exception {
         f.get();                // Future.get() docs require this to throw
     }
 
-    @Test(expected=CancellationException.class)
+    @Test(expected = CancellationException.class)
     public void testGetWithTimeoutAfterCancel() throws Exception {
         Observable<String> obs = Observable.create(new OperationNeverComplete<String>());
         Future<String> f = toFuture(obs);
@@ -118,7 +118,7 @@ public void testGetWithEmptyObservable() throws Throwable {
         try {
             f.get();
         }
-        catch(ExecutionException e) {
+        catch (ExecutionException e) {
             throw e.getCause();
         }
     }
diff --git a/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java b/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
index 6d09cfb950..c3ad148e75 100644
--- a/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
+++ b/src/test/java/rx/internal/operators/DeferredScalarSubscriberTest.java
@@ -317,14 +317,14 @@ public void emissionRequestRace() {
                     @Override
                     public void call() {
                         ready.decrementAndGet();
-                        while (ready.get() != 0) ;
+                        while (ready.get() != 0) { }
 
                         ts.requestMore(1);
                     }
                 });
 
                 ready.decrementAndGet();
-                while (ready.get() != 0) ;
+                while (ready.get() != 0) { }
 
                 ds.onCompleted();
 
@@ -361,7 +361,7 @@ public void emissionRequestRace2() {
                     @Override
                     public void call() {
                         ready.decrementAndGet();
-                        while (ready.get() != 0) ;
+                        while (ready.get() != 0) { }
 
                         ts.requestMore(1);
                     }
@@ -371,14 +371,14 @@ public void call() {
                     @Override
                     public void call() {
                         ready.decrementAndGet();
-                        while (ready.get() != 0) ;
+                        while (ready.get() != 0) { }
 
                         ts.requestMore(1);
                     }
                 });
 
                 ready.decrementAndGet();
-                while (ready.get() != 0) ;
+                while (ready.get() != 0) { }
 
                 ds.onCompleted();
 
diff --git a/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java b/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java
index 1fb0518112..b5ebd07e5e 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeCombineLatestTest.java
@@ -831,7 +831,7 @@ public Long call(Long t1, Integer t2) {
         assertEquals(SIZE, count.get());
     }
 
-    @Test(timeout=10000)
+    @Test(timeout = 10000)
     public void testCombineLatestRequestOverflow() throws InterruptedException {
         @SuppressWarnings("unchecked")
         List<Observable<Integer>> sources = Arrays.asList(Observable.from(Arrays.asList(1,2,3,4)), Observable.from(Arrays.asList(5,6,7,8)));
@@ -862,7 +862,7 @@ public void onError(Throwable e) {
             @Override
             public void onNext(Integer t) {
                 latch.countDown();
-                request(Long.MAX_VALUE-1);
+                request(Long.MAX_VALUE - 1);
             }});
         assertTrue(latch.await(10, TimeUnit.SECONDS));
     }
diff --git a/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java b/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
index 397b6496be..8cf5bdd2cc 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
@@ -124,7 +124,7 @@ public void testIssue1451Case1() {
         // https://github.com/Netflix/RxJava/issues/1451
         final int expectedCount = 3;
         final AtomicInteger count = new AtomicInteger();
-        for (int i=0; i < expectedCount; i++) {
+        for (int i = 0; i < expectedCount; i++) {
             Observable
                     .just(Boolean.TRUE, Boolean.FALSE)
                     .takeWhile(new Func1<Boolean, Boolean>() {
@@ -150,7 +150,7 @@ public void testIssue1451Case2() {
         // https://github.com/Netflix/RxJava/issues/1451
         final int expectedCount = 3;
         final AtomicInteger count = new AtomicInteger();
-        for (int i=0; i < expectedCount; i++) {
+        for (int i = 0; i < expectedCount; i++) {
             Observable
                     .just(Boolean.TRUE, Boolean.FALSE, Boolean.FALSE)
                     .takeWhile(new Func1<Boolean, Boolean>() {
@@ -288,7 +288,7 @@ public void call(Integer t) {
     @Test
     public void testIfOnNextActionFailsEmitsErrorAndReportsMoreErrorsToRxJavaHooksNotDownstream() {
         try {
-            final List<Throwable> list= new CopyOnWriteArrayList<Throwable>();
+            final List<Throwable> list = new CopyOnWriteArrayList<Throwable>();
             RxJavaHooks.setOnError(new Action1<Throwable>() {
 
                 @Override
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
index b7579b5b6f..8298625a9b 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
@@ -145,7 +145,7 @@ public void normalError() {
 
     @Test
     public void overflowErrorIsNotFollowedByAnotherErrorDueToOnNextFromUpstream() {
-        Action1<Emitter<Integer>> source = new Action1<Emitter<Integer>>(){
+        Action1<Emitter<Integer>> source = new Action1<Emitter<Integer>>() {
 
             @Override
             public void call(Emitter<Integer> emitter) {
@@ -164,7 +164,7 @@ public void call(Emitter<Integer> emitter) {
 
     @Test
     public void overflowErrorIsNotFollowedByAnotherCompletedDueToCompletedFromUpstream() {
-        Action1<Emitter<Integer>> source = new Action1<Emitter<Integer>>(){
+        Action1<Emitter<Integer>> source = new Action1<Emitter<Integer>>() {
 
             @Override
             public void call(Emitter<Integer> emitter) {
@@ -191,7 +191,7 @@ public void call(Throwable t) {
                     list.add(t);
                 }});
             final RuntimeException e = new RuntimeException();
-            Action1<Emitter<Integer>> source = new Action1<Emitter<Integer>>(){
+            Action1<Emitter<Integer>> source = new Action1<Emitter<Integer>>() {
 
                 @Override
                 public void call(Emitter<Integer> emitter) {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java
index 4feca72cdd..43993ca137 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java
@@ -66,7 +66,7 @@ public void testRawIterable() {
             public Iterator<String> iterator() {
                 return new Iterator<String>() {
 
-                    int i = 0;
+                    int i;
 
                     @Override
                     public boolean hasNext() {
@@ -184,7 +184,7 @@ public void onError(Throwable e) {
             @Override
             public void onNext(Integer t) {
                 latch.countDown();
-                request(Long.MAX_VALUE-1);
+                request(Long.MAX_VALUE - 1);
             }});
         assertTrue(latch.await(10, TimeUnit.SECONDS));
     }
@@ -237,8 +237,9 @@ public boolean hasNext() {
                         if (count > 1) {
                             called.set(true);
                             return false;
-                        } else
+                        } else {
                             return true;
+                        }
                     }
 
                     @Override
@@ -274,8 +275,9 @@ public boolean hasNext() {
                         if (count > 1) {
                             called.set(true);
                             return false;
-                        } else
+                        } else {
                             return true;
+                        }
                     }
 
                     @Override
diff --git a/src/test/java/rx/internal/operators/OnSubscribeMapTest.java b/src/test/java/rx/internal/operators/OnSubscribeMapTest.java
index 4cc589a7cc..6477bdbdc5 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeMapTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeMapTest.java
@@ -278,7 +278,7 @@ public Observable<Object> call(Object object) {
         };
 
         Func1<Object, Object> mapper = new Func1<Object, Object>() {
-            private int count = 0;
+            private int count;
 
             @Override
             public Object call(Object object) {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java b/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
index 68b860d97f..e169cbb68e 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
@@ -280,7 +280,7 @@ public void testUsingDisposesEagerlyBeforeCompletion() {
         final List<String> events = new ArrayList<String>();
         Func0<Resource> resourceFactory = createResourceFactory(events);
         final Action0 completion = createOnCompletedAction(events);
-        final Action0 unsub =createUnsubAction(events);
+        final Action0 unsub = createUnsubAction(events);
 
         Func1<Resource, Observable<String>> observableFactory = new Func1<Resource, Observable<String>>() {
             @Override
@@ -305,7 +305,7 @@ public void testUsingDoesNotDisposesEagerlyBeforeCompletion() {
         final List<String> events = new ArrayList<String>();
         Func0<Resource> resourceFactory = createResourceFactory(events);
         final Action0 completion = createOnCompletedAction(events);
-        final Action0 unsub =createUnsubAction(events);
+        final Action0 unsub = createUnsubAction(events);
 
         Func1<Resource, Observable<String>> observableFactory = new Func1<Resource, Observable<String>>() {
             @Override
diff --git a/src/test/java/rx/internal/operators/OperatorAllTest.java b/src/test/java/rx/internal/operators/OperatorAllTest.java
index 264c0abc88..0ca615d515 100644
--- a/src/test/java/rx/internal/operators/OperatorAllTest.java
+++ b/src/test/java/rx/internal/operators/OperatorAllTest.java
@@ -236,9 +236,9 @@ public void request(long n) {
             boolean once = true;
             @Override
             public Boolean call(Integer t) {
-                if (once)
+                if (once) {
                     throw new RuntimeException("boo");
-                else  {
+                } else  {
                     once = false;
                     return true;
                 }
diff --git a/src/test/java/rx/internal/operators/OperatorAnyTest.java b/src/test/java/rx/internal/operators/OperatorAnyTest.java
index 7ddbfa6a23..776d6e8f72 100644
--- a/src/test/java/rx/internal/operators/OperatorAnyTest.java
+++ b/src/test/java/rx/internal/operators/OperatorAnyTest.java
@@ -298,9 +298,9 @@ public void request(long n) {
             boolean once = true;
             @Override
             public Boolean call(Integer t) {
-                if (once)
+                if (once) {
                     throw new RuntimeException("boo");
-                else  {
+                } else  {
                     once = false;
                     return true;
                 }
diff --git a/src/test/java/rx/internal/operators/OperatorBufferTest.java b/src/test/java/rx/internal/operators/OperatorBufferTest.java
index 2a14f7797e..99f4cf5c0f 100644
--- a/src/test/java/rx/internal/operators/OperatorBufferTest.java
+++ b/src/test/java/rx/internal/operators/OperatorBufferTest.java
@@ -309,7 +309,7 @@ public void testLongTimeAction() throws InterruptedException {
     private static class LongTimeAction implements Action1<List<Integer>> {
 
         CountDownLatch latch;
-        boolean fail = false;
+        boolean fail;
 
         public LongTimeAction(CountDownLatch latch) {
             this.latch = latch;
diff --git a/src/test/java/rx/internal/operators/OperatorConcatTest.java b/src/test/java/rx/internal/operators/OperatorConcatTest.java
index 99f4ae1a25..564eb9e709 100644
--- a/src/test/java/rx/internal/operators/OperatorConcatTest.java
+++ b/src/test/java/rx/internal/operators/OperatorConcatTest.java
@@ -84,11 +84,11 @@ public void testConcatMapIterable() {
         final String[] l = { "a", "b", "c", "d", "e" };
 
         Func1<List<String>,List<String>> identity = new Func1<List<String>, List<String>>() {
-			@Override
-			public List<String> call(List<String> t) {
-				return t;
-			}
-		};
+            @Override
+            public List<String> call(List<String> t) {
+                return t;
+            }
+        };
 
         final Observable<List<String>> listObs = Observable.just(Arrays.asList(l));
         final Observable<String> concatMap = listObs.concatMapIterable(identity);
@@ -497,8 +497,8 @@ public boolean isUnsubscribed() {
 
         };
         private final List<T> values;
-        private Thread t = null;
-        private int count = 0;
+        private Thread t;
+        private int count;
         private boolean subscribed = true;
         private final CountDownLatch once;
         private final CountDownLatch okToContinue;
@@ -535,20 +535,24 @@ public void call(final Subscriber<? super T> observer) {
                 public void run() {
                     try {
                         while (count < size && subscribed) {
-                            if (null != values)
+                            if (null != values) {
                                 observer.onNext(values.get(count));
-                            else
+                            } else {
                                 observer.onNext(seed);
+                            }
                             count++;
                             //Unblock the main thread to call unsubscribe.
-                            if (null != once)
+                            if (null != once) {
                                 once.countDown();
+                            }
                             //Block until the main thread has called unsubscribe.
-                            if (null != okToContinue)
+                            if (null != okToContinue) {
                                 okToContinue.await(5, TimeUnit.SECONDS);
+                            }
                         }
-                        if (subscribed)
+                        if (subscribed) {
                             observer.onCompleted();
+                        }
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                         fail(e.getMessage());
@@ -821,8 +825,9 @@ public void concatMapRangeAsyncLoopIssue2876() {
         final long startTime = System.currentTimeMillis();
         for (int i = 0;; i++) {
             //only run this for a max of ten seconds
-            if (System.currentTimeMillis()-startTime > TimeUnit.SECONDS.toMillis(durationSeconds))
+            if (System.currentTimeMillis() - startTime > TimeUnit.SECONDS.toMillis(durationSeconds)) {
                 return;
+            }
             if (i % 1000 == 0) {
                 System.out.println("concatMapRangeAsyncLoop > " + i);
             }
diff --git a/src/test/java/rx/internal/operators/OperatorDelayTest.java b/src/test/java/rx/internal/operators/OperatorDelayTest.java
index d92aac8569..8c2bfbf9f2 100644
--- a/src/test/java/rx/internal/operators/OperatorDelayTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDelayTest.java
@@ -671,7 +671,7 @@ public void testBackpressureWithTimedDelay() {
                 .observeOn(Schedulers.computation())
                 .map(new Func1<Integer, Integer>() {
 
-                    int c = 0;
+                    int c;
 
                     @Override
                     public Integer call(Integer t) {
@@ -700,7 +700,7 @@ public void testBackpressureWithSubscriptionTimedDelay() {
                 .observeOn(Schedulers.computation())
                 .map(new Func1<Integer, Integer>() {
 
-                    int c = 0;
+                    int c;
 
                     @Override
                     public Integer call(Integer t) {
@@ -735,7 +735,7 @@ public Observable<Long> call(Integer i) {
                 .observeOn(Schedulers.computation())
                 .map(new Func1<Integer, Integer>() {
 
-                    int c = 0;
+                    int c;
 
                     @Override
                     public Integer call(Integer t) {
@@ -776,7 +776,7 @@ public Observable<Long> call(Integer i) {
                 .observeOn(Schedulers.computation())
                 .map(new Func1<Integer, Integer>() {
 
-                    int c = 0;
+                    int c;
 
                     @Override
                     public Integer call(Integer t) {
diff --git a/src/test/java/rx/internal/operators/OperatorGroupByTest.java b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
index 2b9328795d..2d90e6f29a 100644
--- a/src/test/java/rx/internal/operators/OperatorGroupByTest.java
+++ b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
@@ -1142,7 +1142,7 @@ public Observable<String> call(final GroupedObservable<String, String> g) {
                 System.out.println("-----------> NEXT: " + g.getKey());
                 return g.take(2).map(new Func1<String, String>() {
 
-                    int count = 0;
+                    int count;
 
                     @Override
                     public String call(String v) {
@@ -1264,7 +1264,7 @@ public void call() {
 
                 }).observeOn(Schedulers.computation()).map(new Func1<Integer, String>() {
 
-                    int c = 0;
+                    int c;
 
                     @Override
                     public String call(Integer l) {
@@ -1481,7 +1481,7 @@ public void onError(Throwable e) {
                     public void onNext(Integer t) {
                         System.out.println(t);
                         //provoke possible request overflow
-                        request(Long.MAX_VALUE-1);
+                        request(Long.MAX_VALUE - 1);
                     }});
         assertTrue(completed.get());
     }
@@ -1812,10 +1812,10 @@ public Integer call(Integer pair) {
 
     @Test
     public void mapFactoryEvictionWorks() {
-        Func1<Integer, Integer> keySelector = new Func1<Integer, Integer> (){
+        Func1<Integer, Integer> keySelector = new Func1<Integer, Integer> () {
             @Override
             public Integer call(Integer t) {
-                return t /10;
+                return t / 10;
             }};
         Func1<Integer, Integer> elementSelector = UtilityFunctions.identity();
         final List<Integer> evictedKeys = new ArrayList<Integer>();
@@ -1831,7 +1831,7 @@ public Map<Integer, Object> call(final Action1<Integer> evicted) {
                 return new ConcurrentHashMap<Integer,Object>() {
                     private static final long serialVersionUID = -7519109652858021153L;
 
-                    Integer lastKey = null;
+                    Integer lastKey;
 
                     @Override
                     public Object put(Integer key, Object value) {
@@ -1867,7 +1867,7 @@ public String call(Integer x) {
                 .map(new Func1<Integer, String>() {
                         @Override
                         public String call(Integer x) {
-                            return (x /10) + ":" + x;
+                            return (x / 10) + ":" + x;
                         }
                     })
                 .toList().toBlocking().single();
@@ -1876,10 +1876,10 @@ public String call(Integer x) {
 
     private static final Func1<Integer, Integer> EVICTING_MAP_ELEMENT_SELECTOR = UtilityFunctions.identity();
 
-    private static final Func1<Integer, Integer> EVICTING_MAP_KEY_SELECTOR = new Func1<Integer, Integer> (){
+    private static final Func1<Integer, Integer> EVICTING_MAP_KEY_SELECTOR = new Func1<Integer, Integer> () {
         @Override
         public Integer call(Integer t) {
-            return t /10;
+            return t / 10;
         }};
 
     @Test
@@ -1969,7 +1969,7 @@ public String call(Integer x) {
                 .map(new Func1<Integer, String>() {
                         @Override
                         public String call(Integer x) {
-                            return (x /10) + ":" + x;
+                            return (x / 10) + ":" + x;
                         }
                     })
                 .toList().toBlocking().single();
@@ -1996,7 +1996,7 @@ public void testEvictingMapFactoryIfMapCreateThrowsRuntimeExceptionThenErrorEmit
         ts.assertError(exception);
     }
 
-    @Test(expected=OnErrorNotImplementedException.class)
+    @Test(expected = OnErrorNotImplementedException.class)
     public void testEvictingMapFactoryIfMapCreateThrowsFatalErrorThenSubscribeThrows() {
         final OnErrorNotImplementedException exception = new OnErrorNotImplementedException("boo", new RuntimeException());
         Func1<Action1<Integer>, Map<Integer, Object>> mapFactory = createMapFactoryThatThrowsOnCreate(exception);
diff --git a/src/test/java/rx/internal/operators/OperatorMaterializeTest.java b/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
index 1ddaa6c45d..af090b4379 100644
--- a/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
@@ -203,8 +203,8 @@ public void testUnsubscribeJustBeforeCompletionNotificationShouldPreventThatNoti
 
     private static class TestObserver extends Subscriber<Notification<String>> {
 
-        boolean onCompleted = false;
-        boolean onError = false;
+        boolean onCompleted;
+        boolean onError;
         List<Notification<String>> notifications = new Vector<Notification<String>>();
 
         @Override
diff --git a/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java b/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
index 56aa690b84..56685b1630 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
@@ -92,7 +92,7 @@ private static class SubscriptionCheckObservable implements Observable.OnSubscri
 
         private final AtomicInteger subscriptionCount;
         private final int maxConcurrent;
-        volatile boolean failed = false;
+        volatile boolean failed;
 
         SubscriptionCheckObservable(AtomicInteger subscriptionCount, int maxConcurrent) {
             this.subscriptionCount = subscriptionCount;
diff --git a/src/test/java/rx/internal/operators/OperatorMergeTest.java b/src/test/java/rx/internal/operators/OperatorMergeTest.java
index 746f794158..d79649667d 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeTest.java
@@ -667,13 +667,14 @@ public void testBackpressureDownstreamWithConcurrentStreams() throws Interrupted
         TestSubscriber<Integer> testSubscriber = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
-                if (t < 100)
+                if (t < 100) {
                     try {
                         // force a slow consumer
                         Thread.sleep(1);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
+                }
                 //                System.err.println("testSubscriber received => " + t + "  on thread " + Thread.currentThread());
                 super.onNext(t);
             }
@@ -708,13 +709,14 @@ public Observable<Integer> call(Integer t1) {
         TestSubscriber<Integer> testSubscriber = new TestSubscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
-                if (t < 100)
+                if (t < 100) {
                     try {
                         // force a slow consumer
                         Thread.sleep(2);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
+                }
                 //                System.err.println("testSubscriber received => " + t + "  on thread " + Thread.currentThread());
                 super.onNext(t);
             }
@@ -759,17 +761,18 @@ public Observable<Integer> call(Integer t1) {
         });
 
         TestSubscriber<Integer> testSubscriber = new TestSubscriber<Integer>() {
-            int i = 0;
+            int i;
 
             @Override
             public void onNext(Integer t) {
-                if (i++ < 400)
+                if (i++ < 400) {
                     try {
                         // force a slow consumer
                         Thread.sleep(1);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
+                }
                 //                System.err.println("testSubscriber received => " + t + "  on thread " + Thread.currentThread());
                 super.onNext(t);
             }
@@ -1197,7 +1200,7 @@ public void onError(Throwable e) {
             public void onNext(Integer t) {
                 latch.countDown();
                 request(2);
-                request(Long.MAX_VALUE-1);
+                request(Long.MAX_VALUE - 1);
             }});
         assertTrue(latch.await(10, TimeUnit.SECONDS));
     }
@@ -1311,7 +1314,7 @@ public void onNext(Integer t) {
     @Test
     public void testUnboundedDefaultConcurrency() {
         List<Observable<Integer>> os = new ArrayList<Observable<Integer>>();
-        for(int i=0; i < 2000; i++) {
+        for (int i = 0; i < 2000; i++) {
             os.add(Observable.<Integer>never());
         }
         os.add(Observable.range(0, 100));
@@ -1326,7 +1329,7 @@ public void testUnboundedDefaultConcurrency() {
     @Test
     public void testConcurrencyLimit() {
         List<Observable<Integer>> os = new ArrayList<Observable<Integer>>();
-        for(int i=0; i < 2000; i++) {
+        for (int i = 0; i < 2000; i++) {
             os.add(Observable.<Integer>never());
         }
         os.add(Observable.range(0, 100));
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
index aef7303848..ea48f2847e 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
@@ -129,7 +129,7 @@ public void call() {
 
         int size = ts.getOnNextEvents().size();
         assertTrue(size <= 150);  // will get up to 50 more
-        assertTrue(ts.getOnNextEvents().get(size-1) == size-1);
+        assertTrue(ts.getOnNextEvents().get(size - 1) == size - 1);
         assertTrue(s.isUnsubscribed());
     }
 
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
index 947af54695..87d748e2ea 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
@@ -121,7 +121,7 @@ public void onError(Throwable e) {
             public void onNext(Long t) {
                 count.incrementAndGet();
                 //cause overflow of requested if not handled properly in onBackpressureDrop operator
-                request(Long.MAX_VALUE-1);
+                request(Long.MAX_VALUE - 1);
             }});
         assertEquals(n, count.get());
     }
@@ -308,7 +308,7 @@ private static final Observable<Long> range(final long n) {
 
             @Override
             public void call(Subscriber<? super Long> s) {
-                for (long i=0;i < n;i++) {
+                for (long i = 0;i < n;i++) {
                     if (s.isUnsubscribed()) {
                         break;
                     }
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java
index cbcd3d26f8..a226159529 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureLatestTest.java
@@ -124,7 +124,7 @@ public void onNext(Integer t) {
                 if (rnd.nextDouble() < 0.001) {
                     try {
                         Thread.sleep(1);
-                    } catch(InterruptedException ex) {
+                    } catch (InterruptedException ex) {
                         ex.printStackTrace();
                     }
                 }
diff --git a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java
index d4ec5d756d..9076e2f542 100644
--- a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java
@@ -242,8 +242,9 @@ public void testMapResumeAsyncNext() {
         w = w.map(new Func1<String, String>() {
             @Override
             public String call(String s) {
-                if ("fail".equals(s))
+                if ("fail".equals(s)) {
                     throw new RuntimeException("Forced Failure");
+                }
                 System.out.println("BadMapper:" + s);
                 return s;
             }
@@ -277,7 +278,7 @@ private static class TestObservable implements Observable.OnSubscribe<String> {
 
         final Subscription s;
         final String[] values;
-        Thread t = null;
+        Thread t;
 
         public TestObservable(Subscription s, String... values) {
             this.s = s;
@@ -326,7 +327,7 @@ public Observable<Integer> call(Throwable t1) {
                 })
                 .observeOn(Schedulers.computation())
                 .map(new Func1<Integer, Integer>() {
-                    int c = 0;
+                    int c;
 
                     @Override
                     public Integer call(Integer t1) {
diff --git a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java
index 418324f7f4..a7315a9158 100644
--- a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java
@@ -79,8 +79,9 @@ public void testMapResumeAsyncNext() {
         w = w.map(new Func1<String, String>() {
             @Override
             public String call(String s) {
-                if ("fail".equals(s))
+                if ("fail".equals(s)) {
                     throw new RuntimeException("Forced Failure");
+                }
                 System.out.println("BadMapper:" + s);
                 return s;
             }
@@ -158,7 +159,7 @@ private static class TestObservable implements Observable.OnSubscribe<String> {
 
         final Subscription s;
         final String[] values;
-        Thread t = null;
+        Thread t;
 
         public TestObservable(Subscription s, String... values) {
             this.s = s;
@@ -176,8 +177,9 @@ public void run() {
                     try {
                         System.out.println("running TestObservable thread");
                         for (String s : values) {
-                            if ("fail".equals(s))
+                            if ("fail".equals(s)) {
                                 throw new RuntimeException("Forced Failure");
+                            }
                             System.out.println("TestObservable onNext: " + s);
                             observer.onNext(s);
                         }
@@ -203,7 +205,7 @@ public void testBackpressure() {
                 .onErrorResumeNext(Observable.just(1))
                 .observeOn(Schedulers.computation())
                 .map(new Func1<Integer, Integer>() {
-                    int c = 0;
+                    int c;
 
                     @Override
                     public Integer call(Integer t1) {
diff --git a/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java b/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java
index 1b08ced1ca..57a16e7829 100644
--- a/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java
@@ -119,8 +119,9 @@ public void testMapResumeAsyncNext() {
         w = w.map(new Func1<String, String>() {
             @Override
             public String call(String s) {
-                if ("fail".equals(s))
+                if ("fail".equals(s)) {
                     throw new RuntimeException("Forced Failure");
+                }
                 System.out.println("BadMapper:" + s);
                 return s;
             }
@@ -163,7 +164,7 @@ public Integer call(Throwable t1) {
                 })
                 .observeOn(Schedulers.computation())
                 .map(new Func1<Integer, Integer>() {
-                    int c = 0;
+                    int c;
 
                     @Override
                     public Integer call(Integer t1) {
@@ -187,7 +188,7 @@ public Integer call(Integer t1) {
     private static class TestObservable implements Observable.OnSubscribe<String> {
 
         final String[] values;
-        Thread t = null;
+        Thread t;
 
         public TestObservable(String... values) {
             this.values = values;
diff --git a/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java b/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java
index 7522ae6d86..3b403f90e1 100644
--- a/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java
@@ -156,8 +156,9 @@ public void testMapResumeAsyncNext() {
         w = w.map(new Func1<String, String>() {
             @Override
             public String call(String s) {
-                if ("fail".equals(s))
+                if ("fail".equals(s)) {
                     throw new RuntimeException("Forced Failure");
+                }
                 System.out.println("BadMapper:" + s);
                 return s;
             }
@@ -195,7 +196,7 @@ public void testBackpressure() {
                 .onExceptionResumeNext(Observable.just(1))
                 .observeOn(Schedulers.computation())
                 .map(new Func1<Integer, Integer>() {
-                    int c = 0;
+                    int c;
 
                     @Override
                     public Integer call(Integer t1) {
@@ -220,7 +221,7 @@ public Integer call(Integer t1) {
     private static class TestObservable implements Observable.OnSubscribe<String> {
 
         final String[] values;
-        Thread t = null;
+        Thread t;
 
         public TestObservable(String... values) {
             this.values = values;
@@ -236,14 +237,15 @@ public void run() {
                     try {
                         System.out.println("running TestObservable thread");
                         for (String s : values) {
-                            if ("EXCEPTION".equals(s))
+                            if ("EXCEPTION".equals(s)) {
                                 throw new Exception("Forced Exception");
-                            else if ("RUNTIMEEXCEPTION".equals(s))
+                            } else if ("RUNTIMEEXCEPTION".equals(s)) {
                                 throw new RuntimeException("Forced RuntimeException");
-                            else if ("ON_OVERFLOW_ERROR".equals(s))
+                            } else if ("ON_OVERFLOW_ERROR".equals(s)) {
                                 throw new Error("Forced Error");
-                            else if ("THROWABLE".equals(s))
+                            } else if ("THROWABLE".equals(s)) {
                                 throw new Throwable("Forced Throwable");
+                            }
                             System.out.println("TestObservable onNext: " + s);
                             observer.onNext(s);
                         }
diff --git a/src/test/java/rx/internal/operators/OperatorPublishTest.java b/src/test/java/rx/internal/operators/OperatorPublishTest.java
index ba2f114742..d0f524159f 100644
--- a/src/test/java/rx/internal/operators/OperatorPublishTest.java
+++ b/src/test/java/rx/internal/operators/OperatorPublishTest.java
@@ -98,7 +98,7 @@ public void call() {
 
         });
         Observable<Integer> slow = is.observeOn(Schedulers.computation()).map(new Func1<Integer, Integer>() {
-            int c = 0;
+            int c;
 
             @Override
             public Integer call(Integer i) {
diff --git a/src/test/java/rx/internal/operators/OperatorRetryTest.java b/src/test/java/rx/internal/operators/OperatorRetryTest.java
index 100891b792..7937f8945f 100644
--- a/src/test/java/rx/internal/operators/OperatorRetryTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRetryTest.java
@@ -57,9 +57,9 @@ public void call(Subscriber<? super String> t1) {
                 if (count.getAndDecrement() == 0) {
                     t1.onNext("hello");
                     t1.onCompleted();
-                }
-                else
+                } else {
                     t1.onError(new RuntimeException());
+                }
             }
 
         });
@@ -75,7 +75,7 @@ public Observable<?> call(Observable<? extends Throwable> attempts) {
                         public Tuple call(Throwable n) {
                             return new Tuple(new Long(1), n);
                         }})
-                    .scan(new Func2<Tuple, Tuple, Tuple>(){
+                    .scan(new Func2<Tuple, Tuple, Tuple>() {
                         @Override
                         public Tuple call(Tuple t, Tuple n) {
                             return new Tuple(t.count + n.count, n.n);
@@ -83,10 +83,10 @@ public Tuple call(Tuple t, Tuple n) {
                     .flatMap(new Func1<Tuple, Observable<Long>>() {
                         @Override
                         public Observable<Long> call(Tuple t) {
-                            System.out.println("Retry # "+t.count);
+                            System.out.println("Retry # " + t.count);
                             return t.count > 20 ?
                                 Observable.<Long>error(t.n) :
-                                Observable.timer(t.count *1L, TimeUnit.MILLISECONDS);
+                                Observable.timer(t.count * 1L, TimeUnit.MILLISECONDS);
                     }});
             }
         }).subscribe(ts);
@@ -398,7 +398,7 @@ public void call(final Subscriber<? super String> o) {
                 final AtomicLong req = new AtomicLong();
                 // 0 = not set, 1 = fast path, 2 = backpressure
                 final AtomicInteger path = new AtomicInteger(0);
-                volatile boolean done = false;
+                volatile boolean done;
 
                 @Override
                 public void request(long n) {
@@ -463,7 +463,7 @@ public void testRetryAllowsSubscriptionAfterAllSubscriptionsUnsubscribed() throw
             public void call(Subscriber<? super String> s) {
                 subsCount.incrementAndGet();
                 s.add(new Subscription() {
-                    boolean unsubscribed = false;
+                    boolean unsubscribed;
 
                     @Override
                     public void unsubscribe() {
@@ -695,7 +695,7 @@ public void testTimeoutWithRetry() {
     @Test//(timeout = 15000)
     public void testRetryWithBackpressure() throws InterruptedException {
         final int NUM_LOOPS = 1;
-        for (int j=0;j<NUM_LOOPS;j++) {
+        for (int j = 0; j < NUM_LOOPS; j++) {
             final int NUM_RETRIES = RxRingBuffer.SIZE * 2;
             for (int i = 0; i < 400; i++) {
                 @SuppressWarnings("unchecked")
@@ -870,7 +870,7 @@ public void testIssue1900SourceNotSupportingBackpressure() {
 
             @Override
             public void call(Subscriber<? super String> o) {
-                for(int i=0; i<NUM_MSG; i++) {
+                for (int i = 0; i < NUM_MSG; i++) {
                     o.onNext("msg:" + count.incrementAndGet());
                 }
                 o.onCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java b/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java
index 1fa33dc646..f526d327f6 100644
--- a/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java
@@ -320,7 +320,7 @@ public Integer call(Integer t1) {
     public void testIssue3008RetryWithPredicate() {
         final List<Long> list = new CopyOnWriteArrayList<Long>();
         final AtomicBoolean isFirst = new AtomicBoolean(true);
-        Observable.<Long> just(1L, 2L, 3L).map(new Func1<Long, Long>(){
+        Observable.<Long> just(1L, 2L, 3L).map(new Func1<Long, Long>() {
             @Override
             public Long call(Long x) {
                 System.out.println("map " + x);
@@ -348,7 +348,7 @@ public void call(Long t) {
     public void testIssue3008RetryInfinite() {
         final List<Long> list = new CopyOnWriteArrayList<Long>();
         final AtomicBoolean isFirst = new AtomicBoolean(true);
-        Observable.<Long> just(1L, 2L, 3L).map(new Func1<Long, Long>(){
+        Observable.<Long> just(1L, 2L, 3L).map(new Func1<Long, Long>() {
             @Override
             public Long call(Long x) {
                 System.out.println("map " + x);
diff --git a/src/test/java/rx/internal/operators/OperatorSerializeTest.java b/src/test/java/rx/internal/operators/OperatorSerializeTest.java
index 153df50fa2..450e2e0185 100644
--- a/src/test/java/rx/internal/operators/OperatorSerializeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSerializeTest.java
@@ -223,7 +223,7 @@ private enum TestConcurrencyobserverEvent {
     private static class TestSingleThreadedObservable implements Observable.OnSubscribe<String> {
 
         final String[] values;
-        private Thread t = null;
+        private Thread t;
 
         public TestSingleThreadedObservable(final String... values) {
             this.values = values;
@@ -270,7 +270,7 @@ public void waitToFinish() {
      */
     private static class TestMultiThreadedObservable implements Observable.OnSubscribe<String> {
         final String[] values;
-        Thread t = null;
+        Thread t;
         AtomicInteger threadsRunning = new AtomicInteger();
         AtomicInteger maxConcurrentThreads = new AtomicInteger();
         ExecutorService threadPool;
@@ -302,8 +302,9 @@ public void run() {
                                             System.out.println("TestMultiThreadedObservable onNext: null");
                                             // force an error
                                             throw npe;
-                                        } else
+                                        } else {
                                             System.out.println("TestMultiThreadedObservable onNext: " + s);
+                                        }
                                         observer.onNext(s);
                                         // capture 'maxThreads'
                                         int concurrentThreads = threadsRunning.get();
@@ -350,8 +351,8 @@ public void waitToFinish() {
     }
 
     private static class BusyObserver extends Subscriber<String> {
-        volatile boolean onCompleted = false;
-        volatile boolean onError = false;
+        volatile boolean onCompleted;
+        volatile boolean onError;
         AtomicInteger onNextCount = new AtomicInteger();
         AtomicInteger threadsRunning = new AtomicInteger();
         AtomicInteger maxConcurrentThreads = new AtomicInteger();
diff --git a/src/test/java/rx/internal/operators/OperatorSkipTest.java b/src/test/java/rx/internal/operators/OperatorSkipTest.java
index 649c562bb2..fdfd12de1d 100644
--- a/src/test/java/rx/internal/operators/OperatorSkipTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSkipTest.java
@@ -172,7 +172,7 @@ public void call(Long n) {
 
     @Test
     public void testRequestOverflowDoesNotOccur() {
-        TestSubscriber<Integer> ts = new TestSubscriber<Integer>(Long.MAX_VALUE-1);
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>(Long.MAX_VALUE - 1);
         Observable.range(1, 10).skip(5).subscribe(ts);
         ts.assertTerminalEvent();
         ts.assertCompleted();
diff --git a/src/test/java/rx/internal/operators/OperatorSkipWhileTest.java b/src/test/java/rx/internal/operators/OperatorSkipWhileTest.java
index f17b3ac07a..205ed930bb 100644
--- a/src/test/java/rx/internal/operators/OperatorSkipWhileTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSkipWhileTest.java
@@ -44,14 +44,15 @@ public class OperatorSkipWhileTest {
     private static final Func1<Integer, Boolean> LESS_THAN_FIVE = new Func1<Integer, Boolean>() {
         @Override
         public Boolean call(Integer v) {
-            if (v == 42)
+            if (v == 42) {
                 throw new RuntimeException("that's not the answer to everything!");
+            }
             return v < 5;
         }
     };
 
     private static final Func1<Integer, Boolean> INDEX_LESS_THAN_THREE = new Func1<Integer, Boolean>() {
-        int index = 0;
+        int index;
         @Override
         public Boolean call(Integer value) {
             return index++ < 3;
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchTest.java b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
index 9b1d1be8b4..1a8732e341 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
@@ -412,16 +412,16 @@ public void testBackpressure() {
             public void call(final Subscriber<? super String> observer) {
                 observer.setProducer(new Producer() {
 
-                    private int emitted = 0;
+                    private int emitted;
 
                     @Override
                     public void request(long n) {
-                        for(int i = 0; i < n && emitted < 10 && !observer.isUnsubscribed(); i++) {
+                        for (int i = 0; i < n && emitted < 10 && !observer.isUnsubscribed(); i++) {
                             scheduler.advanceTimeBy(5, TimeUnit.MILLISECONDS);
                             emitted++;
                             observer.onNext("a" + emitted);
                         }
-                        if(emitted == 10) {
+                        if (emitted == 10) {
                             observer.onCompleted();
                         }
                     }
@@ -433,16 +433,16 @@ public void request(long n) {
             public void call(final Subscriber<? super String> observer) {
                 observer.setProducer(new Producer() {
 
-                    private int emitted = 0;
+                    private int emitted;
 
                     @Override
                     public void request(long n) {
-                        for(int i = 0; i < n && emitted < 10 && !observer.isUnsubscribed(); i++) {
+                        for (int i = 0; i < n && emitted < 10 && !observer.isUnsubscribed(); i++) {
                             scheduler.advanceTimeBy(5, TimeUnit.MILLISECONDS);
                             emitted++;
                             observer.onNext("b" + emitted);
                         }
-                        if(emitted == 10) {
+                        if (emitted == 10) {
                             observer.onCompleted();
                         }
                     }
@@ -454,15 +454,15 @@ public void request(long n) {
             public void call(final Subscriber<? super String> observer) {
                 observer.setProducer(new Producer() {
 
-                    private int emitted = 0;
+                    private int emitted;
 
                     @Override
                     public void request(long n) {
-                        for(int i = 0; i < n && emitted < 10 && !observer.isUnsubscribed(); i++) {
+                        for (int i = 0; i < n && emitted < 10 && !observer.isUnsubscribed(); i++) {
                             emitted++;
                             observer.onNext("c" + emitted);
                         }
-                        if(emitted == 10) {
+                        if (emitted == 10) {
                             observer.onCompleted();
                         }
                     }
@@ -481,7 +481,7 @@ public void call(Subscriber<? super Observable<String>> observer) {
         final TestSubscriber<String> testSubscriber = new TestSubscriber<String>();
         Observable.switchOnNext(o).subscribe(new Subscriber<String>() {
 
-            private int requested = 0;
+            private int requested;
 
             @Override
             public void onStart() {
@@ -503,7 +503,7 @@ public void onError(Throwable e) {
             public void onNext(String s) {
                 testSubscriber.onNext(s);
                 requested--;
-                if(requested == 0) {
+                if (requested == 0) {
                     requested = 3;
                     request(3);
                 }
@@ -657,7 +657,7 @@ public Observable<Long> call(Long t) {
         ts.awaitTerminalEvent();
         assertTrue(ts.getOnNextEvents().size() > 0);
         assertEquals(4, requests.size()); // depends on the request pattern
-        assertEquals(Long.MAX_VALUE, (long) requests.get(requests.size()-1));
+        assertEquals(Long.MAX_VALUE, (long) requests.get(requests.size() - 1));
     }
 
     @Test
diff --git a/src/test/java/rx/internal/operators/OperatorTakeLastTest.java b/src/test/java/rx/internal/operators/OperatorTakeLastTest.java
index 23a4361f0f..1a2eddec64 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeLastTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeLastTest.java
@@ -133,7 +133,7 @@ public void testBackpressure2() {
 
     private Func1<Integer, Integer> newSlowProcessor() {
         return new Func1<Integer, Integer>() {
-            int c = 0;
+            int c;
 
             @Override
             public Integer call(Integer i) {
@@ -292,7 +292,7 @@ public void onNext(Integer integer) {
         assertEquals(1,count.get());
     }
 
-    @Test(timeout=10000)
+    @Test(timeout = 10000)
     public void testRequestOverflow() {
         final List<Integer> list = new ArrayList<Integer>();
         Observable.range(1, 100).takeLast(50).subscribe(new Subscriber<Integer>() {
@@ -315,7 +315,7 @@ public void onError(Throwable e) {
             @Override
             public void onNext(Integer t) {
                 list.add(t);
-                request(Long.MAX_VALUE-1);
+                request(Long.MAX_VALUE - 1);
             }});
         assertEquals(50, list.size());
     }
@@ -343,7 +343,7 @@ public void completionRequestRace() {
                 w.schedule(new Action0() {
                     @Override
                     public void call() {
-                        while (!go.get());
+                        while (!go.get()) { }
                         ts.requestMore(n + 1);
                     }
                 });
diff --git a/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java b/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java
index 70794d1aa1..491825d3f9 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeLastTimedTest.java
@@ -237,7 +237,7 @@ public void completionRequestRace() {
                 w.schedule(new Action0() {
                     @Override
                     public void call() {
-                        while (!go.get());
+                        while (!go.get()) { }
                         ts.requestMore(n + 1);
                     }
                 });
diff --git a/src/test/java/rx/internal/operators/OperatorTakeTest.java b/src/test/java/rx/internal/operators/OperatorTakeTest.java
index c056e8b8f8..0dc3dbc8c4 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeTest.java
@@ -245,7 +245,7 @@ public void call(Integer t1) {
     private static class TestObservableFunc implements Observable.OnSubscribe<String> {
 
         final String[] values;
-        Thread t = null;
+        Thread t;
 
         public TestObservableFunc(String... values) {
             this.values = values;
diff --git a/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java b/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
index f51aa9cd26..28c0c432ff 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
@@ -163,7 +163,7 @@ public void testTakeUntilOtherCompleted() {
 
     private static class TestObservable implements Observable.OnSubscribe<String> {
 
-        Observer<? super String> observer = null;
+        Observer<? super String> observer;
         Subscription s;
 
         public TestObservable(Subscription s) {
diff --git a/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java b/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java
index f80b863f9c..0a3cd3ec94 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java
@@ -87,7 +87,7 @@ public Boolean call(Integer input) {
     public void testTakeWhile2() {
         Observable<String> w = Observable.just("one", "two", "three");
         Observable<String> take = w.takeWhile(new Func1<String, Boolean>() {
-            int index = 0;
+            int index;
 
             @Override
             public Boolean call(String input) {
@@ -158,7 +158,7 @@ public void testUnsubscribeAfterTake() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         Observable<String> take = Observable.create(w).takeWhile(new Func1<String, Boolean>() {
-            int index = 0;
+            int index;
 
             @Override
             public Boolean call(String s) {
@@ -186,7 +186,7 @@ private static class TestObservable implements Observable.OnSubscribe<String> {
 
         final Subscription s;
         final String[] values;
-        Thread t = null;
+        Thread t;
 
         public TestObservable(Subscription s, String... values) {
             this.s = s;
diff --git a/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java b/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
index 456f48a998..d2d0e2e567 100644
--- a/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
@@ -393,7 +393,7 @@ public void run() {
                 source.timeout(timeoutFunc, Observable.just(3)).subscribe(ts);
                 source.onNext(1); // start timeout
                 try {
-                    if(!enteredTimeoutOne.await(30, TimeUnit.SECONDS)) {
+                    if (!enteredTimeoutOne.await(30, TimeUnit.SECONDS)) {
                         latchTimeout.set(true);
                     }
                 } catch (InterruptedException e) {
@@ -401,7 +401,7 @@ public void run() {
                 }
                 source.onNext(2); // disable timeout
                 try {
-                    if(!timeoutEmittedOne.await(30, TimeUnit.SECONDS)) {
+                    if (!timeoutEmittedOne.await(30, TimeUnit.SECONDS)) {
                         latchTimeout.set(true);
                     }
                 } catch (InterruptedException e) {
@@ -412,7 +412,7 @@ public void run() {
 
         }).start();
 
-        if(!observerCompleted.await(30, TimeUnit.SECONDS)) {
+        if (!observerCompleted.await(30, TimeUnit.SECONDS)) {
             latchTimeout.set(true);
         }
 
diff --git a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
index 2fb7bc4d28..5081c2cb63 100644
--- a/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
+++ b/src/test/java/rx/internal/operators/OperatorToObservableSortedListTest.java
@@ -259,11 +259,11 @@ public void testSortedWithNonComparable() {
         testSubscriber.assertNotCompleted();
     }
 
-    final static class NonComparable{
+    final static class NonComparable {
         public int i;
         public String s;
 
-        NonComparable(int i, String s){
+        NonComparable(int i, String s) {
             this.i = i;
             this.s = s;
         }
diff --git a/src/test/java/rx/internal/operators/OperatorZipIterableTest.java b/src/test/java/rx/internal/operators/OperatorZipIterableTest.java
index d82465428d..bfcd20c09d 100644
--- a/src/test/java/rx/internal/operators/OperatorZipIterableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorZipIterableTest.java
@@ -366,8 +366,8 @@ static final class SquareStr implements Func1<Integer, String> {
         @Override
         public String call(Integer t1) {
             counter.incrementAndGet();
-            System.out.println("Omg I'm calculating so hard: " + t1 + "*" + t1 + "=" + (t1*t1));
-            return " " + (t1*t1);
+            System.out.println("Omg I'm calculating so hard: " + t1 + "*" + t1 + "=" + (t1 * t1));
+            return " " + (t1 * t1);
         }
     }
 
diff --git a/src/test/java/rx/internal/operators/OperatorZipTest.java b/src/test/java/rx/internal/operators/OperatorZipTest.java
index 950d506201..908f44a23d 100644
--- a/src/test/java/rx/internal/operators/OperatorZipTest.java
+++ b/src/test/java/rx/internal/operators/OperatorZipTest.java
@@ -1315,7 +1315,7 @@ public void testZipRace() {
         // time limit of 9 seconds ( 1 second less than the test timeout) is
         // used so that this test will not timeout on slow machines.
         int i = 0;
-        while (System.currentTimeMillis()-startTime < 9000 && i++ < 100000) {
+        while (System.currentTimeMillis() - startTime < 9000 && i++ < 100000) {
             int value = Observable.zip(src, src, new Func2<Integer, Integer, Integer>() {
                 @Override
                 public Integer call(Integer t1, Integer t2) {
diff --git a/src/test/java/rx/internal/operators/SafeSubscriberTest.java b/src/test/java/rx/internal/operators/SafeSubscriberTest.java
index 8cd7c18031..cf71a8f5d1 100644
--- a/src/test/java/rx/internal/operators/SafeSubscriberTest.java
+++ b/src/test/java/rx/internal/operators/SafeSubscriberTest.java
@@ -126,7 +126,7 @@ public void testOnErrorAfterOnCompleted() {
      */
     private static class TestObservable implements Observable.OnSubscribe<String> {
 
-        Observer<? super String> observer = null;
+        Observer<? super String> observer;
 
         /* used to simulate subscription */
         public void sendOnCompleted() {
diff --git a/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java b/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java
index 61c2015b4e..e8fc60ead5 100644
--- a/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java
+++ b/src/test/java/rx/internal/operators/SingleOnSubscribeUsingTest.java
@@ -273,7 +273,7 @@ public void disposesEagerlyBeforeCompletion() {
         final List<String> events = new ArrayList<String>();
         Func0<Resource> resourceFactory = createResourceFactory(events);
         final Action1<String> completion = createOnSuccessAction(events);
-        final Action0 unsub =createUnsubAction(events);
+        final Action0 unsub = createUnsubAction(events);
 
         Func1<Resource, Single<String>> observableFactory = new Func1<Resource, Single<String>>() {
             @Override
@@ -298,7 +298,7 @@ public void doesNotDisposesEagerlyBeforeCompletion() {
         final List<String> events = new ArrayList<String>();
         Func0<Resource> resourceFactory = createResourceFactory(events);
         final Action1<String> completion = createOnSuccessAction(events);
-        final Action0 unsub =createUnsubAction(events);
+        final Action0 unsub = createUnsubAction(events);
 
         Func1<Resource, Single<String>> observableFactory = new Func1<Resource, Single<String>>() {
             @Override
diff --git a/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java b/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
index d3e074df04..f21753f4a3 100644
--- a/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
+++ b/src/test/java/rx/internal/producers/SingleDelayedProducerTest.java
@@ -56,14 +56,14 @@ public void requestCompleteRace() throws Exception {
                     @Override
                     public void call() {
                         waiter.decrementAndGet();
-                        while (waiter.get() != 0) ;
+                        while (waiter.get() != 0) { }
                         pa.request(1);
                         cdl.countDown();
                     }
                 });
 
                 waiter.decrementAndGet();
-                while (waiter.get() != 0) ;
+                while (waiter.get() != 0) { }
                 pa.setValue(1);
                 if (!cdl.await(5, TimeUnit.SECONDS)) {
                     Assert.fail("The wait for completion timed out");
diff --git a/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java b/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java
index 4368953241..f162ad958b 100644
--- a/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java
+++ b/src/test/java/rx/internal/schedulers/NewThreadWorkerTest.java
@@ -49,7 +49,7 @@ public void findSetRemoveOnCancelPolicyMethodShouldNotFindMethod() {
 
     private static abstract class ScheduledExecutorServiceWithSetRemoveOnCancelPolicy implements ScheduledExecutorService {
         // Just declaration of required method to allow run tests on JDK 6
-        public void setRemoveOnCancelPolicy(boolean value) {}
+        public void setRemoveOnCancelPolicy(boolean value) { }
     }
 
     @Test
diff --git a/src/test/java/rx/internal/util/IndexedRingBufferTest.java b/src/test/java/rx/internal/util/IndexedRingBufferTest.java
index 5ed75ea5e5..233557ac08 100644
--- a/src/test/java/rx/internal/util/IndexedRingBufferTest.java
+++ b/src/test/java/rx/internal/util/IndexedRingBufferTest.java
@@ -186,7 +186,7 @@ public Boolean call(String t1) {
 
         list.clear();
         nextIndex = buffer.forEach(new Func1<String, Boolean>() {
-            int i = 0;
+            int i;
 
             @Override
             public Boolean call(String t1) {
diff --git a/src/test/java/rx/internal/util/JCToolsQueueTests.java b/src/test/java/rx/internal/util/JCToolsQueueTests.java
index 1ec3c202bb..eb89381d94 100644
--- a/src/test/java/rx/internal/util/JCToolsQueueTests.java
+++ b/src/test/java/rx/internal/util/JCToolsQueueTests.java
@@ -169,7 +169,7 @@ public void run() {
 
         Integer j;
         for (int i = 0; i < 1000 * 1000; i++) {
-            while ((j = q.poll()) == null);
+            while ((j = q.poll()) == null) { }
             assertTrue("Value " + j + " already removed", set.remove(j));
         }
         assertTrue("Set is not empty", set.isEmpty());
@@ -242,7 +242,7 @@ public void run() {
 
         Integer j;
         for (int i = 0; i < 1000 * 1000; i++) {
-            while ((j = q.poll()) == null);
+            while ((j = q.poll()) == null) { }
             assertTrue("Value " + j + " already removed", set.remove(j));
         }
         assertTrue("Set is not empty", set.isEmpty());
@@ -366,7 +366,7 @@ public void testSpscLinkedAtomicQueuePipelined() throws InterruptedException {
             public void run() {
                 Integer j;
                 for (int i = 0; i < 1000 * 1000; i++) {
-                    while ((j = q.poll()) == null);
+                    while ((j = q.poll()) == null) { }
                     if (j == i) {
                         count.getAndIncrement();
                     }
@@ -424,7 +424,7 @@ public void testSpscLinkedQueuePipelined() throws InterruptedException {
             public void run() {
                 Integer j;
                 for (int i = 0; i < 1000 * 1000; i++) {
-                    while ((j = q.poll()) == null);
+                    while ((j = q.poll()) == null) { }
                     if (j == i) {
                         count.getAndIncrement();
                     }
diff --git a/src/test/java/rx/internal/util/SynchronizedQueueTest.java b/src/test/java/rx/internal/util/SynchronizedQueueTest.java
deleted file mode 100644
index 977c458d7c..0000000000
--- a/src/test/java/rx/internal/util/SynchronizedQueueTest.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/**
- * Copyright 2016 Netflix, Inc.
- *
- * 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 rx.internal.util;
-
-import static org.junit.Assert.assertTrue;
-
-import java.util.*;
-
-import org.junit.*;
-
-public class SynchronizedQueueTest {
-    SynchronizedQueue<Object> q = new SynchronizedQueue<Object>();
-
-    @Test
-    public void testEquals() {
-
-         assertTrue(q.equals(q));
-    }
-
-    @Test
-    public void contains() {
-        q.offer(1);
-        Assert.assertTrue(q.add(2));
-
-        Assert.assertEquals(2, q.size());
-        Assert.assertTrue(q.contains(1));
-        Assert.assertTrue(q.contains(2));
-        Assert.assertFalse(q.contains(3));
-    }
-
-    @Test
-    public void iterator() {
-        q.offer(1);
-
-        Assert.assertEquals(1, q.iterator().next());
-    }
-
-    @Test
-    public void remove() {
-        q.offer(1);
-        q.offer(2);
-        q.offer(3);
-
-        Assert.assertTrue(q.remove(2));
-        Assert.assertFalse(q.remove(2));
-    }
-
-    @Test
-    public void addAllContainsAll() {
-        q.addAll(Arrays.asList(1, 2, 3, 4));
-
-        q.removeAll(Arrays.asList(2, 3));
-
-        Assert.assertEquals(2, q.size());
-        Assert.assertTrue(q.contains(1));
-        Assert.assertFalse(q.contains(2));
-        Assert.assertFalse(q.contains(3));
-        Assert.assertTrue(q.contains(4));
-
-        Assert.assertTrue(q.containsAll(Arrays.asList(1, 4)));
-        Assert.assertFalse(q.containsAll(Arrays.asList(2, 3)));
-    }
-
-    @Test
-    public void retainAll() {
-        q.addAll(Arrays.asList(1, 2, 3, 4));
-
-        q.retainAll(Arrays.asList(2, 3));
-
-        Assert.assertEquals(2, q.size());
-        Assert.assertFalse(q.contains(1));
-        Assert.assertTrue(q.contains(2));
-        Assert.assertTrue(q.contains(3));
-        Assert.assertFalse(q.contains(4));
-    }
-
-    @Test
-    public void clear() {
-        q.addAll(Arrays.asList(1, 2, 3, 4));
-
-        q.clear();
-
-        Assert.assertEquals(0, q.size());
-        Assert.assertTrue(q.isEmpty());
-    }
-
-    @Test
-    public void toStringValue() {
-        q.offer(1);
-
-        Assert.assertEquals("[1]", q.toString());
-    }
-
-    @Test
-    public void equalsTo() {
-        q.offer(1);
-
-        SynchronizedQueue<Integer> q2 = new SynchronizedQueue<Integer>();
-        q2.offer(1);
-
-        SynchronizedQueue<Integer> q3 = new SynchronizedQueue<Integer>();
-        q3.offer(2);
-
-        Assert.assertEquals(q, q2);
-        Assert.assertEquals(q.hashCode(), q2.hashCode());
-        Assert.assertNotEquals(q, q3);
-
-        Assert.assertFalse(q.equals(null));
-        Assert.assertFalse(q.equals(1));
-
-        Assert.assertEquals(q, q.clone());
-
-    }
-
-    @Test
-    public void toArray() {
-        q.offer(1);
-
-        Object[] a = q.toArray();
-
-        Object[] b = q.toArray(new Integer[1]);
-
-        Assert.assertEquals(1, a[0]);
-        Assert.assertEquals(1, b[0]);
-    }
-
-    @Test
-    public void peekElement() {
-        q.offer(1);
-
-        Assert.assertEquals(1, q.peek());
-        Assert.assertEquals(1, q.element());
-        Assert.assertEquals(1, q.remove());
-        try {
-            q.element();
-            Assert.fail("Failed to throw on empty queue");
-        } catch (NoSuchElementException ex) {
-            // expected
-        }
-    }
-}
diff --git a/src/test/java/rx/observables/AsyncOnSubscribeTest.java b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
index 931b7c1d3f..a711d92c91 100644
--- a/src/test/java/rx/observables/AsyncOnSubscribeTest.java
+++ b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
@@ -60,12 +60,12 @@ public void setup() {
     @Test
     public void testSerializesConcurrentObservables() throws InterruptedException {
         final TestScheduler scheduler = new TestScheduler();
-        AsyncOnSubscribe<Integer, Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        AsyncOnSubscribe<Integer, Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return 1;
             }},
-        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
+        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                 if (state == 1) {
@@ -76,9 +76,9 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
                 else if (state == 2) {
                     Observable<Integer> o = Observable.just(5, 6, 7, 8);
                     observer.onNext(o);
-                }
-                else
+                } else {
                     observer.onCompleted();
+                }
                 return state + 1;
             }});
         // initial request emits [[1, 2, 3, 4]] on delay
@@ -105,7 +105,7 @@ else if (state == 2) {
     public void testSubscribedByBufferingOperator() {
         final TestScheduler scheduler = new TestScheduler();
         OnSubscribe<Integer> os = AsyncOnSubscribe.createStateless(
-        new Action2<Long, Observer<Observable<? extends Integer>>>(){
+        new Action2<Long, Observer<Observable<? extends Integer>>>() {
             @Override
             public void call(Long requested, Observer<Observable<? extends Integer>> observer) {
                 observer.onNext(Observable.range(1, requested.intValue()));
@@ -121,19 +121,19 @@ public void call(Long requested, Observer<Observable<? extends Integer>> observe
     @Test
     public void testOnUnsubscribeHasCorrectState() throws InterruptedException {
         final AtomicInteger lastState = new AtomicInteger(-1);
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return 1;
             }},
-        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
+        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                 if (state < 3) {
                     observer.onNext(Observable.just(state));
-                }
-                else
+                } else {
                     observer.onCompleted();
+                }
                 return state + 1;
             }},
         new Action1<Integer>() {
@@ -153,7 +153,7 @@ public void call(Integer t) {
 
     @Test
     public void testOnCompleteOuter() throws InterruptedException {
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateless(new Action2<Long, Observer<Observable<? extends Integer>>>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateless(new Action2<Long, Observer<Observable<? extends Integer>>>() {
             @Override
             public void call(Long requested, Observer<Observable<? extends Integer>> observer) {
                 observer.onCompleted();
@@ -167,7 +167,7 @@ public void call(Long requested, Observer<Observable<? extends Integer>> observe
 
     @Test
     public void testTryOnNextTwice() throws InterruptedException {
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateless(new Action2<Long, Observer<Observable<? extends Integer>>>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateless(new Action2<Long, Observer<Observable<? extends Integer>>>() {
             @Override
             public void call(Long requested, Observer<Observable<? extends Integer>> observer) {
                 observer.onNext(Observable.just(1));
@@ -184,7 +184,7 @@ public void call(Long requested, Observer<Observable<? extends Integer>> observe
     @Test
     public void testThrowException() throws InterruptedException {
         OnSubscribe<Integer> os = AsyncOnSubscribe.createStateless(
-        new Action2<Long, Observer<Observable<? extends Integer>>>(){
+        new Action2<Long, Observer<Observable<? extends Integer>>>() {
             @Override
             public void call(Long requested, Observer<Observable<? extends Integer>> observer) {
                 throw new TestException();
@@ -198,12 +198,12 @@ public void call(Long requested, Observer<Observable<? extends Integer>> observe
 
     @Test
     public void testThrowExceptionAfterTerminal() throws InterruptedException {
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return 1;
             }},
-        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
+        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                 observer.onCompleted();
@@ -218,12 +218,12 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
 
     @Test
     public void testOnNextAfterCompleted() throws InterruptedException {
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return 1;
             }},
-        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
+        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                 observer.onCompleted();
@@ -239,12 +239,12 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
 
     @Test
     public void testOnNextAfterError() throws InterruptedException {
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return 1;
             }},
-        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
+        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                 observer.onError(new TestException());
@@ -260,12 +260,12 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
 
     @Test
     public void testEmittingEmptyObservable() throws InterruptedException {
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return 1;
             }},
-        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
+        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                 observer.onNext(Observable.<Integer>empty());
@@ -281,12 +281,12 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
 
     @Test
     public void testOnErrorOuter() throws InterruptedException {
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return 1;
             }},
-        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
+        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                 observer.onError(new TestException());
@@ -302,12 +302,12 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
 
     @Test
     public void testOnCompleteFollowedByOnErrorOuter() throws InterruptedException {
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return 1;
             }},
-        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
+        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                 observer.onCompleted();
@@ -326,19 +326,19 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
     public void testUnsubscribesFromAllSelfTerminatedObservables() throws InterruptedException {
         final AtomicInteger l1 = new AtomicInteger();
         final AtomicInteger l2 = new AtomicInteger();
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return 1;
             }},
-        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
+        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                 Observable<Integer> o1;
                 switch (state) {
                 case 1:
                     o1 = Observable.just(1)
-                            .doOnUnsubscribe(new Action0(){
+                            .doOnUnsubscribe(new Action0() {
                                 @Override
                                 public void call() {
                                     l1.incrementAndGet();
@@ -346,7 +346,7 @@ public void call() {
                     break;
                 case 2:
                     o1 = Observable.just(2)
-                            .doOnUnsubscribe(new Action0(){
+                            .doOnUnsubscribe(new Action0() {
                                 @Override
                                 public void call() {
                                     l2.incrementAndGet();
@@ -380,19 +380,19 @@ public void testUnsubscribesFromAllNonTerminatedObservables() throws Interrupted
         final AtomicInteger l2 = new AtomicInteger();
         final TestScheduler scheduler = new TestScheduler();
         final AtomicReference<Subscription> sub = new AtomicReference<Subscription>();
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>() {
                 @Override
                 public Integer call() {
                     return 1;
                 }},
-            new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
+            new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
                 @Override
                 public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                     switch (state) {
                     case 1:
                         observer.onNext(Observable.range(1, requested.intValue())
                                 .subscribeOn(scheduler)
-                                .doOnUnsubscribe(new Action0(){
+                                .doOnUnsubscribe(new Action0() {
                                     @Override
                                     public void call() {
                                         l1.incrementAndGet();
@@ -402,7 +402,7 @@ public void call() {
                         observer.onNext(Observable.just(1)
                                 .concatWith(Observable.<Integer>never())
                                 .subscribeOn(scheduler)
-                                .doOnUnsubscribe(new Action0(){
+                                .doOnUnsubscribe(new Action0() {
                                     @Override
                                     public void call() {
                                         l2.incrementAndGet();
@@ -429,29 +429,30 @@ public void call() {
         assertEquals("did not unsub from Observable.never() inner obs", 1, l2.get());
     }
 
-    private static class Foo {}
-    private static class Bar extends Foo {}
+    private static class Foo { }
+    private static class Bar extends Foo { }
 
     @Test
     public void testGenerics() {
-        AsyncOnSubscribe.createStateless(new Action2<Long, Observer<Observable<? extends Foo>>>(){
+        AsyncOnSubscribe.createStateless(new Action2<Long, Observer<Observable<? extends Foo>>>() {
             @Override
             public void call(Long state, Observer<Observable<? extends Foo>> observer) {
-                if (state == null)
+                if (state == null) {
                     observer.onNext(Observable.just(new Foo()));
-                else
+                } else {
                     observer.onNext(Observable.just(new Bar()));
+                }
             }});
     }
 
     @Test
     public void testUnderdeliveryCorrection() {
-        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = AsyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return 1;
             }},
-        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>(){
+        new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
             @Override
             public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> observer) {
                 switch (state) {
diff --git a/src/test/java/rx/observables/BlockingObservableTest.java b/src/test/java/rx/observables/BlockingObservableTest.java
index 43e0889318..dfb57d26ff 100644
--- a/src/test/java/rx/observables/BlockingObservableTest.java
+++ b/src/test/java/rx/observables/BlockingObservableTest.java
@@ -565,7 +565,7 @@ private Observable<Void> createSynchronousObservable() {
                 @Override
                 public Iterator<Void> iterator() {
                     return new Iterator<Void>() {
-                        private boolean nextCalled = false;
+                        private boolean nextCalled;
 
                         @Override
                         public boolean hasNext() {
diff --git a/src/test/java/rx/observables/SyncOnSubscribeTest.java b/src/test/java/rx/observables/SyncOnSubscribeTest.java
index 398c1a4d45..630561b0a3 100644
--- a/src/test/java/rx/observables/SyncOnSubscribeTest.java
+++ b/src/test/java/rx/observables/SyncOnSubscribeTest.java
@@ -62,7 +62,7 @@ public void call(Observer<? super Integer> subscriber) {
     @Test
     public void testStateAfterTerminal() {
         final AtomicInteger finalStateValue = new AtomicInteger(-1);
-        OnSubscribe<Integer> os = SyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = SyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return 1;
@@ -299,7 +299,7 @@ public void call(Observer<? super Integer> subscriber) {
     public void testRange() {
         final int start = 1;
         final int count = 4000;
-        OnSubscribe<Integer> os = SyncOnSubscribe.createStateful(new Func0<Integer>(){
+        OnSubscribe<Integer> os = SyncOnSubscribe.createStateful(new Func0<Integer>() {
             @Override
             public Integer call() {
                 return start;
@@ -557,7 +557,7 @@ public void call(Observer<? super Void> observer) {
                         observer.onNext(null);
                         currentlyEvaluating.set(false);
                     }},
-                new Action0(){
+                new Action0() {
                     @Override
                     public void call() {
                         calledUnsubscribe.incrementAndGet();
@@ -569,10 +569,10 @@ public void call() {
 
         final CountDownLatch latch = new CountDownLatch(1);
         final TestSubscriber<Object> ts = new TestSubscriber<Object>(o);
-        Observable.create(os).lift(new Operator<Void, Void>(){
+        Observable.create(os).lift(new Operator<Void, Void>() {
             @Override
             public Subscriber<? super Void> call(final Subscriber<? super Void> subscriber) {
-                return new Subscriber<Void>(subscriber){
+                return new Subscriber<Void>(subscriber) {
                     @Override
                     public void setProducer(Producer p) {
                         p.request(1);
@@ -590,7 +590,7 @@ public void onError(Throwable e) {
                     @Override
                     public void onNext(final Void t) {
                         subscriber.onNext(t);
-                        new Thread(new Runnable(){
+                        new Thread(new Runnable() {
                             @Override
                             public void run() {
                                 try {
@@ -709,8 +709,9 @@ public void testObserveOn() {
                     @Override
                     public Integer call(Integer calls, Observer<? super Integer> observer) {
                         observer.onNext(calls);
-                        if (calls == count)
+                        if (calls == count) {
                             observer.onCompleted();
+                        }
                         return calls + 1;
                     }},
                 onUnSubscribe);
@@ -812,10 +813,10 @@ protected void onUnsubscribe(Object state) {
         assertEquals(1, countUnsubs.get());
     }
 
-    private interface FooQux {}
-    private static class Foo implements FooQux {}
-    private interface BarQux extends FooQux {}
-    private static class Bar extends Foo implements BarQux {}
+    private interface FooQux { }
+    private static class Foo implements FooQux { }
+    private interface BarQux extends FooQux { }
+    private static class Bar extends Foo implements BarQux { }
 
     @Test
     public void testGenericsCreateSingleState() {
@@ -932,7 +933,7 @@ private void assertJustBehavior(OnSubscribe<FooQux> os) {
     }
 
     @Test
-    public void testConcurrentUnsubscribe3000Iterations() throws InterruptedException, BrokenBarrierException, ExecutionException{
+    public void testConcurrentUnsubscribe3000Iterations() throws InterruptedException, BrokenBarrierException, ExecutionException {
         ExecutorService exec = null;
         try {
             exec = Executors.newSingleThreadExecutor();
@@ -986,7 +987,9 @@ public Object call() throws Exception {
                 assertEquals("Unsubscribe supposed to be called once", 1, wip.get());
             }
         } finally {
-            if (exec != null) exec.shutdownNow();
+            if (exec != null) {
+                exec.shutdownNow();
+            }
         }
     }
 
diff --git a/src/test/java/rx/observers/SafeSubscriberTest.java b/src/test/java/rx/observers/SafeSubscriberTest.java
index 7d60a71c9f..3fdd8bbf66 100644
--- a/src/test/java/rx/observers/SafeSubscriberTest.java
+++ b/src/test/java/rx/observers/SafeSubscriberTest.java
@@ -80,7 +80,7 @@ public void onCompleted() {
         assertTrue(safe.isUnsubscribed());
     }
 
-    @Test(expected=OnCompletedFailedException.class)
+    @Test(expected = OnCompletedFailedException.class)
     public void testPluginException() {
         RxJavaPlugins.getInstance().registerErrorHandler(new RxJavaErrorHandler() {
             @Override
@@ -261,7 +261,7 @@ public void call() {
         try {
             safe.onCompleted();
             Assert.fail();
-        } catch(UnsubscribeFailedException e) {
+        } catch (UnsubscribeFailedException e) {
             assertEquals(1, calls.get());
             assertEquals(0, errors.get());
         }
@@ -301,7 +301,7 @@ public void call() {
         try {
             safe.onCompleted();
             Assert.fail();
-        } catch(UnsubscribeFailedException e) {
+        } catch (UnsubscribeFailedException e) {
             assertEquals(2, calls.get());
             assertEquals(0, errors.get());
         }
diff --git a/src/test/java/rx/observers/SerializedObserverTest.java b/src/test/java/rx/observers/SerializedObserverTest.java
index 41d6d2da6d..b53ac9fd5d 100644
--- a/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/src/test/java/rx/observers/SerializedObserverTest.java
@@ -589,7 +589,7 @@ public int assertEvents(TestConcurrencyObserverEvent expectedEndingEvent) throws
     private static class TestSingleThreadedObservable implements Observable.OnSubscribe<String> {
 
         final String[] values;
-        private Thread t = null;
+        private Thread t;
 
         public TestSingleThreadedObservable(final String... values) {
             this.values = values;
@@ -637,7 +637,7 @@ public void waitToFinish() {
     private static class TestMultiThreadedObservable implements Observable.OnSubscribe<String> {
 
         final String[] values;
-        Thread t = null;
+        Thread t;
         AtomicInteger threadsRunning = new AtomicInteger();
         AtomicInteger maxConcurrentThreads = new AtomicInteger();
         ExecutorService threadPool;
@@ -726,8 +726,8 @@ public void waitToFinish() {
     }
 
     private static class BusyObserver extends Subscriber<String> {
-        volatile boolean onCompleted = false;
-        volatile boolean onError = false;
+        volatile boolean onCompleted;
+        volatile boolean onError;
         AtomicInteger onNextCount = new AtomicInteger();
         AtomicInteger threadsRunning = new AtomicInteger();
         AtomicInteger maxConcurrentThreads = new AtomicInteger();
diff --git a/src/test/java/rx/plugins/RxJavaPluginsTest.java b/src/test/java/rx/plugins/RxJavaPluginsTest.java
index ebcee62325..1c69ff1389 100644
--- a/src/test/java/rx/plugins/RxJavaPluginsTest.java
+++ b/src/test/java/rx/plugins/RxJavaPluginsTest.java
@@ -72,7 +72,7 @@ public void testErrorHandlerViaProperty() {
     public static class RxJavaErrorHandlerTestImpl extends RxJavaErrorHandler {
 
         private volatile Throwable e;
-        private volatile int count = 0;
+        private volatile int count;
 
         @Override
         public void handleError(Throwable e) {
diff --git a/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 5e5686b396..a7cec8ab86 100644
--- a/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -111,7 +111,7 @@ public void testUnsubscribeRecursiveScheduleFromOutside() throws InterruptedExce
                 public void call() {
                     inner.schedule(new Action0() {
 
-                        int i = 0;
+                        int i;
 
                         @Override
                         public void call() {
@@ -159,7 +159,7 @@ public void testUnsubscribeRecursiveScheduleFromInside() throws InterruptedExcep
                 public void call() {
                     inner.schedule(new Action0() {
 
-                        int i = 0;
+                        int i;
 
                         @Override
                         public void call() {
@@ -239,7 +239,7 @@ public void recursionFromOuterActionAndUnsubscribeInside() throws InterruptedExc
         try {
             inner.schedule(new Action0() {
 
-                int i = 0;
+                int i;
 
                 @Override
                 public void call() {
@@ -268,7 +268,7 @@ public void testRecursion() throws InterruptedException {
         try {
             inner.schedule(new Action0() {
 
-                private long i = 0;
+                private long i;
 
                 @Override
                 public void call() {
diff --git a/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index c0502a6fe0..5875328d70 100644
--- a/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -299,7 +299,7 @@ public final void testRecursiveExecutionWithDelayTime() throws InterruptedExcept
 
             inner.schedule(new Action0() {
 
-                int state = 0;
+                int state;
 
                 @Override
                 public void call() {
@@ -328,7 +328,7 @@ public void call(final Subscriber<? super Integer> observer) {
                 final Scheduler.Worker inner = getScheduler().createWorker();
                 observer.add(inner);
                 inner.schedule(new Action0() {
-                    int i = 0;
+                    int i;
 
                     @Override
                     public void call() {
@@ -508,7 +508,7 @@ public void periodicTaskCancelsItself() throws Exception {
                 @Override
                 public void call() {
                     executions[0]++;
-                    while (cancel.get() == null);
+                    while (cancel.get() == null) { }
 
                     cancel.get().unsubscribe();
                     cdl.countDown();
diff --git a/src/test/java/rx/schedulers/ComputationSchedulerTests.java b/src/test/java/rx/schedulers/ComputationSchedulerTests.java
index 0841d815a9..d83a456f56 100644
--- a/src/test/java/rx/schedulers/ComputationSchedulerTests.java
+++ b/src/test/java/rx/schedulers/ComputationSchedulerTests.java
@@ -52,7 +52,7 @@ public void testThreadSafetyWhenSchedulerIsHoppingBetweenThreads() {
             inner.schedule(new Action0() {
 
                 private HashMap<String, Integer> statefulMap = map;
-                int nonThreadSafeCounter = 0;
+                int nonThreadSafeCounter;
 
                 @Override
                 public void call() {
diff --git a/src/test/java/rx/schedulers/SchedulerTests.java b/src/test/java/rx/schedulers/SchedulerTests.java
index c216580284..f750a47d4d 100644
--- a/src/test/java/rx/schedulers/SchedulerTests.java
+++ b/src/test/java/rx/schedulers/SchedulerTests.java
@@ -65,8 +65,12 @@ public static void testUnhandledErrorIsDeliveredToThreadHandler(Scheduler schedu
             assertEquals("Should have received exactly 1 exception", 1, handler.count);
             Throwable cause = handler.caught;
             while (cause != null) {
-                if (error.equals(cause)) break;
-                if (cause == cause.getCause()) break;
+                if (error.equals(cause)) {
+                    break;
+                }
+                if (cause == cause.getCause()) {
+                    break;
+                }
                 cause = cause.getCause();
             }
             assertEquals("Our error should have been delivered to the handler", error, cause);
@@ -105,8 +109,12 @@ public static void testHandledErrorIsNotDeliveredToThreadHandler(Scheduler sched
 
             Throwable cause = observer.error;
             while (cause != null) {
-                if (error.equals(cause)) break;
-                if (cause == cause.getCause()) break;
+                if (error.equals(cause)) {
+                    break;
+                }
+                if (cause == cause.getCause()) {
+                    break;
+                }
                 cause = cause.getCause();
             }
             assertEquals("Our error should have been delivered to the observer", error, cause);
@@ -183,8 +191,8 @@ public void call() {
 
     private static final class CapturingObserver<T> implements Observer<T> {
         CountDownLatch completed = new CountDownLatch(1);
-        int errorCount = 0;
-        int nextCount = 0;
+        int errorCount;
+        int nextCount;
         Throwable error;
 
         @Override
diff --git a/src/test/java/rx/schedulers/SchedulerWhenTest.java b/src/test/java/rx/schedulers/SchedulerWhenTest.java
index ed0e2f3792..c3b9761e64 100644
--- a/src/test/java/rx/schedulers/SchedulerWhenTest.java
+++ b/src/test/java/rx/schedulers/SchedulerWhenTest.java
@@ -30,184 +30,184 @@
 import rx.observers.TestSubscriber;
 
 public class SchedulerWhenTest {
-	@Test
-	public void testAsyncMaxConcurrent() {
-		TestScheduler tSched = new TestScheduler();
-		SchedulerWhen sched = maxConcurrentScheduler(tSched);
-		TestSubscriber<Long> tSub = TestSubscriber.create();
+    @Test
+    public void testAsyncMaxConcurrent() {
+        TestScheduler tSched = new TestScheduler();
+        SchedulerWhen sched = maxConcurrentScheduler(tSched);
+        TestSubscriber<Long> tSub = TestSubscriber.create();
 
-		asyncWork(sched).subscribe(tSub);
+        asyncWork(sched).subscribe(tSub);
 
-		tSub.assertValueCount(0);
+        tSub.assertValueCount(0);
 
-		tSched.advanceTimeBy(0, SECONDS);
-		tSub.assertValueCount(0);
+        tSched.advanceTimeBy(0, SECONDS);
+        tSub.assertValueCount(0);
 
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(2);
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(2);
 
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(4);
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(4);
 
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(5);
-		tSub.assertCompleted();
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(5);
+        tSub.assertCompleted();
 
-		sched.unsubscribe();
-	}
+        sched.unsubscribe();
+    }
+
+    @Test
+    public void testAsyncDelaySubscription() {
+        final TestScheduler tSched = new TestScheduler();
+        SchedulerWhen sched = throttleScheduler(tSched);
+        TestSubscriber<Long> tSub = TestSubscriber.create();
+
+        asyncWork(sched).subscribe(tSub);
+
+        tSub.assertValueCount(0);
+
+        tSched.advanceTimeBy(0, SECONDS);
+        tSub.assertValueCount(0);
+
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(1);
+
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(1);
+
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(2);
+
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(2);
+
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(3);
+
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(3);
+
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(4);
+
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(4);
+
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(5);
+        tSub.assertCompleted();
+
+        sched.unsubscribe();
+    }
+
+    @Test
+    public void testSyncMaxConcurrent() {
+        TestScheduler tSched = new TestScheduler();
+        SchedulerWhen sched = maxConcurrentScheduler(tSched);
+        TestSubscriber<Long> tSub = TestSubscriber.create();
+
+        syncWork(sched).subscribe(tSub);
+
+        tSub.assertValueCount(0);
+        tSched.advanceTimeBy(0, SECONDS);
+
+        // since all the work is synchronous nothing is blocked and its all done
+        tSub.assertValueCount(5);
+        tSub.assertCompleted();
 
-	@Test
-	public void testAsyncDelaySubscription() {
-		final TestScheduler tSched = new TestScheduler();
-		SchedulerWhen sched = throttleScheduler(tSched);
-		TestSubscriber<Long> tSub = TestSubscriber.create();
+        sched.unsubscribe();
+    }
+
+    @Test
+    public void testSyncDelaySubscription() {
+        final TestScheduler tSched = new TestScheduler();
+        SchedulerWhen sched = throttleScheduler(tSched);
+        TestSubscriber<Long> tSub = TestSubscriber.create();
+
+        syncWork(sched).subscribe(tSub);
+
+        tSub.assertValueCount(0);
+
+        tSched.advanceTimeBy(0, SECONDS);
+        tSub.assertValueCount(1);
 
-		asyncWork(sched).subscribe(tSub);
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(2);
 
-		tSub.assertValueCount(0);
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(3);
 
-		tSched.advanceTimeBy(0, SECONDS);
-		tSub.assertValueCount(0);
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(4);
 
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(1);
+        tSched.advanceTimeBy(1, SECONDS);
+        tSub.assertValueCount(5);
+        tSub.assertCompleted();
 
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(1);
+        sched.unsubscribe();
+    }
 
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(2);
+    private Observable<Long> asyncWork(final Scheduler sched) {
+        return Observable.range(1, 5).flatMap(new Func1<Integer, Observable<Long>>() {
+            @Override
+            public Observable<Long> call(Integer t) {
+                return Observable.timer(1, SECONDS, sched);
+            }
+        });
+    }
 
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(2);
+    private Observable<Long> syncWork(final Scheduler sched) {
+        return Observable.range(1, 5).flatMap(new Func1<Integer, Observable<Long>>() {
+            @Override
+            public Observable<Long> call(Integer t) {
+                return Observable.defer(new Func0<Observable<Long>>() {
+                    @Override
+                    public Observable<Long> call() {
+                        return Observable.just(0l);
+                    }
+                }).subscribeOn(sched);
+            }
+        });
+    }
 
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(3);
+    private SchedulerWhen maxConcurrentScheduler(TestScheduler tSched) {
+        SchedulerWhen sched = new SchedulerWhen(new Func1<Observable<Observable<Completable>>, Completable>() {
+            @Override
+            public Completable call(Observable<Observable<Completable>> workerActions) {
+                Observable<Completable> workers = workerActions.map(new Func1<Observable<Completable>, Completable>() {
+                    @Override
+                    public Completable call(Observable<Completable> actions) {
+                        return Completable.concat(actions);
+                    }
+                });
+                return Completable.merge(workers, 2);
+            }
+        }, tSched);
+        return sched;
+    }
 
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(3);
+    private SchedulerWhen throttleScheduler(final TestScheduler tSched) {
+        SchedulerWhen sched = new SchedulerWhen(new Func1<Observable<Observable<Completable>>, Completable>() {
+            @Override
+            public Completable call(Observable<Observable<Completable>> workerActions) {
+                Observable<Completable> workers = workerActions.map(new Func1<Observable<Completable>, Completable>() {
+                    @Override
+                    public Completable call(Observable<Completable> actions) {
+                        return Completable.concat(actions);
+                    }
+                });
+                return Completable.concat(workers.map(new Func1<Completable, Completable>() {
+                    @Override
+                    public Completable call(Completable worker) {
+                        return worker.delay(1, SECONDS, tSched);
+                    }
+                }));
+            }
+        }, tSched);
+        return sched;
+    }
 
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(4);
-
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(4);
-
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(5);
-		tSub.assertCompleted();
-
-		sched.unsubscribe();
-	}
-
-	@Test
-	public void testSyncMaxConcurrent() {
-		TestScheduler tSched = new TestScheduler();
-		SchedulerWhen sched = maxConcurrentScheduler(tSched);
-		TestSubscriber<Long> tSub = TestSubscriber.create();
-
-		syncWork(sched).subscribe(tSub);
-
-		tSub.assertValueCount(0);
-		tSched.advanceTimeBy(0, SECONDS);
-
-		// since all the work is synchronous nothing is blocked and its all done
-		tSub.assertValueCount(5);
-		tSub.assertCompleted();
-
-		sched.unsubscribe();
-	}
-
-	@Test
-	public void testSyncDelaySubscription() {
-		final TestScheduler tSched = new TestScheduler();
-		SchedulerWhen sched = throttleScheduler(tSched);
-		TestSubscriber<Long> tSub = TestSubscriber.create();
-
-		syncWork(sched).subscribe(tSub);
-
-		tSub.assertValueCount(0);
-
-		tSched.advanceTimeBy(0, SECONDS);
-		tSub.assertValueCount(1);
-
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(2);
-
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(3);
-
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(4);
-
-		tSched.advanceTimeBy(1, SECONDS);
-		tSub.assertValueCount(5);
-		tSub.assertCompleted();
-
-		sched.unsubscribe();
-	}
-
-	private Observable<Long> asyncWork(final Scheduler sched) {
-		return Observable.range(1, 5).flatMap(new Func1<Integer, Observable<Long>>() {
-			@Override
-			public Observable<Long> call(Integer t) {
-				return Observable.timer(1, SECONDS, sched);
-			}
-		});
-	}
-
-	private Observable<Long> syncWork(final Scheduler sched) {
-		return Observable.range(1, 5).flatMap(new Func1<Integer, Observable<Long>>() {
-			@Override
-			public Observable<Long> call(Integer t) {
-				return Observable.defer(new Func0<Observable<Long>>() {
-					@Override
-					public Observable<Long> call() {
-						return Observable.just(0l);
-					}
-				}).subscribeOn(sched);
-			}
-		});
-	}
-
-	private SchedulerWhen maxConcurrentScheduler(TestScheduler tSched) {
-		SchedulerWhen sched = new SchedulerWhen(new Func1<Observable<Observable<Completable>>, Completable>() {
-			@Override
-			public Completable call(Observable<Observable<Completable>> workerActions) {
-				Observable<Completable> workers = workerActions.map(new Func1<Observable<Completable>, Completable>() {
-					@Override
-					public Completable call(Observable<Completable> actions) {
-						return Completable.concat(actions);
-					}
-				});
-				return Completable.merge(workers, 2);
-			}
-		}, tSched);
-		return sched;
-	}
-
-	private SchedulerWhen throttleScheduler(final TestScheduler tSched) {
-		SchedulerWhen sched = new SchedulerWhen(new Func1<Observable<Observable<Completable>>, Completable>() {
-			@Override
-			public Completable call(Observable<Observable<Completable>> workerActions) {
-				Observable<Completable> workers = workerActions.map(new Func1<Observable<Completable>, Completable>() {
-					@Override
-					public Completable call(Observable<Completable> actions) {
-						return Completable.concat(actions);
-					}
-				});
-				return Completable.concat(workers.map(new Func1<Completable, Completable>() {
-					@Override
-				    public Completable call(Completable worker) {
-						return worker.delay(1, SECONDS, tSched);
-					}
-				}));
-			}
-		}, tSched);
-		return sched;
-	}
-
-    @Test(timeout=1000)
+    @Test(timeout = 1000)
     public void testRaceConditions() {
         Scheduler comp = Schedulers.computation();
         Scheduler limited = comp.when(new Func1<Observable<Observable<Completable>>, Completable>() {
diff --git a/src/test/java/rx/schedulers/TrampolineSchedulerTest.java b/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
index f191fa9819..61e6b4f3e2 100644
--- a/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
+++ b/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
@@ -125,7 +125,7 @@ public Subscription call(Long count) {
                                          return trampolineWorker.schedule(new Action0() {
 
                                              @Override
-                                             public void call() {}
+                                             public void call() { }
 
                                          });
                                      }
diff --git a/src/test/java/rx/subjects/BufferUntilSubscriberTest.java b/src/test/java/rx/subjects/BufferUntilSubscriberTest.java
index d1ad426a96..6d8aebe167 100644
--- a/src/test/java/rx/subjects/BufferUntilSubscriberTest.java
+++ b/src/test/java/rx/subjects/BufferUntilSubscriberTest.java
@@ -33,8 +33,9 @@ public class BufferUntilSubscriberTest {
     public void testIssue1677() throws InterruptedException {
         final AtomicLong counter = new AtomicLong();
         final Integer[] numbers = new Integer[5000];
-        for (int i = 0; i < numbers.length; i++)
+        for (int i = 0; i < numbers.length; i++) {
             numbers[i] = i + 1;
+        }
         final int NITERS = 250;
         final CountDownLatch latch = new CountDownLatch(NITERS);
         for (int iters = 0; iters < NITERS; iters++) {
@@ -72,13 +73,15 @@ public void call(List<Integer> integers) {
                         }
                     })
                     .subscribe();
-            if (!innerLatch.await(30, TimeUnit.SECONDS))
+            if (!innerLatch.await(30, TimeUnit.SECONDS)) {
                 Assert.fail("Failed inner latch wait, iteration " + iters);
+            }
         }
-        if (!latch.await(30, TimeUnit.SECONDS))
+        if (!latch.await(30, TimeUnit.SECONDS)) {
             Assert.fail("Incomplete! Went through " + latch.getCount() + " iterations");
-        else
+        } else {
             Assert.assertEquals(NITERS, counter.get());
+        }
     }
 
     @Test
diff --git a/src/test/java/rx/util/AssertObservable.java b/src/test/java/rx/util/AssertObservable.java
index 41ddaaad1e..d1a0072a34 100644
--- a/src/test/java/rx/util/AssertObservable.java
+++ b/src/test/java/rx/util/AssertObservable.java
@@ -102,24 +102,30 @@ public Notification<String> call(Notification<T> expectedNotfication, Notificati
                 if (expectedNotfication.equals(actualNotification)) {
                     StringBuilder message = new StringBuilder();
                     message.append(expectedNotfication.getKind());
-                    if (expectedNotfication.hasValue())
+                    if (expectedNotfication.hasValue()) {
                         message.append(" ").append(expectedNotfication.getValue());
-                    if (expectedNotfication.hasThrowable())
+                    }
+                    if (expectedNotfication.hasThrowable()) {
                         message.append(" ").append(expectedNotfication.getThrowable());
+                    }
                     return Notification.createOnNext("equals " + message.toString());
                 }
                 else {
                     StringBuilder error = new StringBuilder();
                     error.append("expected:<").append(expectedNotfication.getKind());
-                    if (expectedNotfication.hasValue())
+                    if (expectedNotfication.hasValue()) {
                         error.append(" ").append(expectedNotfication.getValue());
-                    if (expectedNotfication.hasThrowable())
+                    }
+                    if (expectedNotfication.hasThrowable()) {
                         error.append(" ").append(expectedNotfication.getThrowable());
+                    }
                     error.append("> but was:<").append(actualNotification.getKind());
-                    if (actualNotification.hasValue())
+                    if (actualNotification.hasValue()) {
                         error.append(" ").append(actualNotification.getValue());
-                    if (actualNotification.hasThrowable())
+                    }
+                    if (actualNotification.hasThrowable()) {
                         error.append(" ").append(actualNotification.getThrowable());
+                    }
                     error.append(">");
 
                     return Notification.createOnError(new AssertionError(error.toString()));
@@ -136,10 +142,11 @@ public Notification<String> call(Notification<String> a, Notification<String> b)
                 message += "\n\t" + (b.isOnError() ? b.getThrowable().getMessage() : b.getValue());
                 fail |= b.isOnError();
 
-                if (fail)
+                if (fail) {
                     return Notification.createOnError(new AssertionError(message));
-                else
+                } else {
                     return Notification.createOnNext(message);
+                }
             }
         };
 

From fb3d0e81bce9183272913e33dd5e0aa7b1a021ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?D=C3=A1vid=20Karnok?= <akarnokd@gmail.com>
Date: Mon, 14 Nov 2016 20:14:15 +0100
Subject: [PATCH 198/263] 1.x: fix Completable.concat & merge hanging in async
 situations

---
 .../CompletableOnSubscribeConcat.java         | 74 ++++++++++---------
 .../CompletableOnSubscribeMerge.java          |  2 +-
 .../operators/CompletableConcatTest.java      | 45 +++++++++++
 .../operators/CompletableMergeTest.java       | 45 +++++++++++
 4 files changed, 132 insertions(+), 34 deletions(-)
 create mode 100644 src/test/java/rx/internal/operators/CompletableConcatTest.java
 create mode 100644 src/test/java/rx/internal/operators/CompletableMergeTest.java

diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
index 1960a93207..10a7801beb 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcat.java
@@ -21,9 +21,9 @@
 import rx.*;
 import rx.Completable.OnSubscribe;
 import rx.exceptions.MissingBackpressureException;
+import rx.internal.subscriptions.SequentialSubscription;
 import rx.internal.util.unsafe.SpscArrayQueue;
 import rx.plugins.RxJavaHooks;
-import rx.subscriptions.SerialSubscription;
 
 public final class CompletableOnSubscribeConcat implements OnSubscribe {
     final Observable<Completable> sources;
@@ -39,30 +39,29 @@ public CompletableOnSubscribeConcat(Observable<? extends Completable> sources, i
     public void call(CompletableSubscriber s) {
         CompletableConcatSubscriber parent = new CompletableConcatSubscriber(s, prefetch);
         s.onSubscribe(parent);
-        sources.subscribe(parent);
+        sources.unsafeSubscribe(parent);
     }
 
     static final class CompletableConcatSubscriber
     extends Subscriber<Completable> {
         final CompletableSubscriber actual;
-        final SerialSubscription sr;
+        final SequentialSubscription sr;
 
         final SpscArrayQueue<Completable> queue;
 
-        volatile boolean done;
+        final ConcatInnerSubscriber inner;
 
         final AtomicBoolean once;
 
-        final ConcatInnerSubscriber inner;
+        volatile boolean done;
 
-        final AtomicInteger wip;
+        volatile boolean active;
 
         public CompletableConcatSubscriber(CompletableSubscriber actual, int prefetch) {
             this.actual = actual;
             this.queue = new SpscArrayQueue<Completable>(prefetch);
-            this.sr = new SerialSubscription();
+            this.sr = new SequentialSubscription();
             this.inner = new ConcatInnerSubscriber();
-            this.wip = new AtomicInteger();
             this.once = new AtomicBoolean();
             add(sr);
             request(prefetch);
@@ -74,9 +73,7 @@ public void onNext(Completable t) {
                 onError(new MissingBackpressureException());
                 return;
             }
-            if (wip.getAndIncrement() == 0) {
-                next();
-            }
+            drain();
         }
 
         @Override
@@ -94,9 +91,7 @@ public void onCompleted() {
                 return;
             }
             done = true;
-            if (wip.getAndIncrement() == 0) {
-                next();
-            }
+            drain();
         }
 
         void innerError(Throwable e) {
@@ -105,32 +100,45 @@ void innerError(Throwable e) {
         }
 
         void innerComplete() {
-            if (wip.decrementAndGet() != 0) {
-                next();
-            }
-            if (!done) {
-                request(1);
-            }
+            active = false;
+            drain();
         }
 
-        void next() {
-            boolean d = done;
-            Completable c = queue.poll();
-            if (c == null) {
-                if (d) {
-                    if (once.compareAndSet(false, true)) {
-                        actual.onCompleted();
-                    }
-                    return;
-                }
-                RxJavaHooks.onError(new IllegalStateException("Queue is empty?!"));
+        void drain() {
+            ConcatInnerSubscriber inner = this.inner;
+            if (inner.getAndIncrement() != 0) {
                 return;
             }
 
-            c.unsafeSubscribe(inner);
+            do {
+                if (isUnsubscribed()) {
+                    return;
+                }
+                if (!active) {
+                    boolean d = done;
+                    Completable c = queue.poll();
+                    boolean empty = c == null;
+
+                    if (d && empty) {
+                        actual.onCompleted();
+                        return;
+                    }
+
+                    if (!empty) {
+                        active = true;
+                        c.subscribe(inner);
+
+                        request(1);
+                    }
+                }
+            } while (inner.decrementAndGet() != 0);
         }
 
-        final class ConcatInnerSubscriber implements CompletableSubscriber {
+        final class ConcatInnerSubscriber
+        extends AtomicInteger
+        implements CompletableSubscriber {
+            private static final long serialVersionUID = 7233503139645205620L;
+
             @Override
             public void onSubscribe(Subscription d) {
                 sr.set(d);
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
index 19f5aa3857..b60f6c56ed 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMerge.java
@@ -43,7 +43,7 @@ public CompletableOnSubscribeMerge(Observable<? extends Completable> source, int
     public void call(CompletableSubscriber s) {
         CompletableMergeSubscriber parent = new CompletableMergeSubscriber(s, maxConcurrency, delayErrors);
         s.onSubscribe(parent);
-        source.subscribe(parent);
+        source.unsafeSubscribe(parent);
     }
 
     static final class CompletableMergeSubscriber
diff --git a/src/test/java/rx/internal/operators/CompletableConcatTest.java b/src/test/java/rx/internal/operators/CompletableConcatTest.java
new file mode 100644
index 0000000000..7ce2529322
--- /dev/null
+++ b/src/test/java/rx/internal/operators/CompletableConcatTest.java
@@ -0,0 +1,45 @@
+package rx.internal.operators;
+
+import java.util.concurrent.TimeUnit;
+
+import org.junit.*;
+
+import rx.*;
+import rx.functions.*;
+import rx.schedulers.Schedulers;
+
+public class CompletableConcatTest {
+
+    @Test
+    public void asyncObservables() {
+
+        final int[] calls = { 0 };
+
+        Completable.concat(Observable.range(1, 5).map(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(final Integer v) {
+                System.out.println("Mapping " + v);
+                return Completable.fromAction(new Action0() {
+                    @Override
+                    public void call() {
+                        System.out.println("Processing " + (calls[0] + 1));
+                        calls[0]++;
+                    }
+                })
+                .subscribeOn(Schedulers.io())
+                .doOnCompleted(new Action0() {
+                    @Override
+                    public void call() {
+                        System.out.println("Inner complete " + v);
+                    }
+                })
+                .observeOn(Schedulers.computation());
+            }
+        })
+        ).test()
+        .awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS)
+        .assertResult();
+
+        Assert.assertEquals(5, calls[0]);
+    }
+}
diff --git a/src/test/java/rx/internal/operators/CompletableMergeTest.java b/src/test/java/rx/internal/operators/CompletableMergeTest.java
new file mode 100644
index 0000000000..790d51d5f4
--- /dev/null
+++ b/src/test/java/rx/internal/operators/CompletableMergeTest.java
@@ -0,0 +1,45 @@
+package rx.internal.operators;
+
+import java.util.concurrent.TimeUnit;
+
+import org.junit.*;
+
+import rx.*;
+import rx.functions.*;
+import rx.schedulers.Schedulers;
+
+public class CompletableMergeTest {
+
+    @Test
+    public void asyncObservables() {
+
+        final int[] calls = { 0 };
+
+        Completable.merge(Observable.range(1, 5).map(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(final Integer v) {
+                System.out.println("Mapping " + v);
+                return Completable.fromAction(new Action0() {
+                    @Override
+                    public void call() {
+                        System.out.println("Processing " + (calls[0] + 1));
+                        calls[0]++;
+                    }
+                })
+                .subscribeOn(Schedulers.io())
+                .doOnCompleted(new Action0() {
+                    @Override
+                    public void call() {
+                        System.out.println("Inner complete " + v);
+                    }
+                })
+                .observeOn(Schedulers.computation());
+            }
+        }), 1
+        ).test()
+        .awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS)
+        .assertResult();
+
+        Assert.assertEquals(5, calls[0]);
+    }
+}

From a825d70701b3a013fc7ab882a10d61a856f4e351 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 15 Nov 2016 10:22:06 +0100
Subject: [PATCH 199/263] 1.x: add Single.fromEmitter

---
 src/main/java/rx/Single.java                  |  40 ++++
 src/main/java/rx/SingleEmitter.java           |  70 ++++++
 .../operators/CompletableFromEmitter.java     |   6 +-
 .../operators/OnSubscribeFromEmitter.java     |  41 +---
 .../internal/operators/SingleFromEmitter.java | 118 ++++++++++
 .../CancellableSubscription.java              |  43 ++++
 .../operators/SingleFromEmitterTest.java      | 221 ++++++++++++++++++
 7 files changed, 497 insertions(+), 42 deletions(-)
 create mode 100644 src/main/java/rx/SingleEmitter.java
 create mode 100644 src/main/java/rx/internal/operators/SingleFromEmitter.java
 create mode 100644 src/main/java/rx/internal/subscriptions/CancellableSubscription.java
 create mode 100644 src/test/java/rx/internal/operators/SingleFromEmitterTest.java

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 7b85c4d3a5..782d5c833f 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -573,6 +573,46 @@ public static <T> Single<T> fromCallable(final Callable<? extends T> func) {
         return create(new SingleFromCallable<T>(func));
     }
 
+    /**
+     * Provides an API (in a cold Single) that bridges the Single-reactive world
+     * with the callback-based world.
+     * <p>The {@link SingleEmitter} allows registering a callback for
+     * cancellation/unsubscription of a resource.
+     * <p>
+     * Example:
+     * <pre><code>
+     * Single.fromEmitter(emitter -&gt; {
+     *     Callback listener = new Callback() {
+     *         &#64;Override
+     *         public void onEvent(Event e) {
+     *             emitter.onSuccess(e.getData());
+     *         }
+     *
+     *         &#64;Override
+     *         public void onFailure(Exception e) {
+     *             emitter.onError(e);
+     *         }
+     *     };
+     *
+     *     AutoCloseable c = api.someMethod(listener);
+     *
+     *     emitter.setCancellation(c::close);
+     *
+     * });
+     * </code></pre>
+     * <p>All of the SingleEmitter's methods are thread-safe and ensure the
+     * Single's protocol are held.
+     * @param <T> the success value type
+     * @param producer the callback invoked for each incoming SingleSubscriber
+     * @return the new Single instance
+     * @since 1.2.3 - experimental (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     */
+    @Experimental
+    public static <T> Single<T> fromEmitter(Action1<SingleEmitter<T>> producer) {
+        if (producer == null) { throw new NullPointerException("producer is null"); }
+        return create(new SingleFromEmitter<T>(producer));
+    }
+
     /**
      * Returns a {@code Single} that emits a specified item.
      * <p>
diff --git a/src/main/java/rx/SingleEmitter.java b/src/main/java/rx/SingleEmitter.java
new file mode 100644
index 0000000000..c4f3d11615
--- /dev/null
+++ b/src/main/java/rx/SingleEmitter.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx;
+
+import rx.annotations.Experimental;
+import rx.functions.Cancellable;
+
+/**
+ * Abstraction over a {@link SingleSubscriber} that gets either an onSuccess or onError
+ * signal and allows registering an cancellation/unsubscription callback.
+ * <p>
+ * All methods are thread-safe; calling onSuccess or onError twice or one after the other has
+ * no effect.
+ * @since 1.2.3 - experimental (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ * 
+ * @param <T> the success value type
+ */
+@Experimental
+public interface SingleEmitter<T> {
+
+    /**
+     * Notifies the SingleSubscriber that the {@link Single} has completed successfully with
+     * the given value.
+     * <p>
+     * If the {@link Single} calls this method, it will not thereafter call
+     * {@link #onError}.
+     *
+     * @param t the success value
+     */
+    void onSuccess(T t);
+
+    /**
+     * Notifies the SingleSubscriber that the {@link Single} has experienced an error condition.
+     * <p>
+     * If the {@link Single} calls this method, it will not thereafter call
+     * {@link #onSuccess}.
+     *
+     * @param t
+     *          the exception encountered by the Observable
+     */
+    void onError(Throwable t);
+
+    /**
+     * Sets a Subscription on this emitter; any previous Subscription
+     * or Cancellation will be unsubscribed/cancelled.
+     * @param s the subscription, null is allowed
+     */
+    void setSubscription(Subscription s);
+
+    /**
+     * Sets a Cancellable on this emitter; any previous Subscription
+     * or Cancellation will be unsubscribed/cancelled.
+     * @param c the cancellable resource, null is allowed
+     */
+    void setCancellation(Cancellable c);
+
+}
diff --git a/src/main/java/rx/internal/operators/CompletableFromEmitter.java b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
index 1b7cea57c2..3be42f7aac 100644
--- a/src/main/java/rx/internal/operators/CompletableFromEmitter.java
+++ b/src/main/java/rx/internal/operators/CompletableFromEmitter.java
@@ -19,10 +19,8 @@
 
 import rx.*;
 import rx.exceptions.Exceptions;
-import rx.functions.Action1;
-import rx.functions.Cancellable;
-import rx.internal.operators.OnSubscribeFromEmitter.CancellableSubscription;
-import rx.internal.subscriptions.SequentialSubscription;
+import rx.functions.*;
+import rx.internal.subscriptions.*;
 import rx.plugins.RxJavaHooks;
 
 /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java b/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
index 2cfec566d4..355ae99c1d 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
@@ -20,9 +20,9 @@
 
 import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.exceptions.*;
-import rx.functions.Action1;
-import rx.functions.Cancellable;
+import rx.exceptions.MissingBackpressureException;
+import rx.functions.*;
+import rx.internal.subscriptions.CancellableSubscription;
 import rx.internal.util.RxRingBuffer;
 import rx.internal.util.atomic.SpscUnboundedAtomicArrayQueue;
 import rx.internal.util.unsafe.*;
@@ -73,41 +73,6 @@ public void call(Subscriber<? super T> t) {
 
     }
 
-    /**
-     * A Subscription that wraps an Cancellable instance.
-     */
-    static final class CancellableSubscription
-    extends AtomicReference<Cancellable>
-    implements Subscription {
-
-        /** */
-        private static final long serialVersionUID = 5718521705281392066L;
-
-        public CancellableSubscription(Cancellable cancellable) {
-            super(cancellable);
-        }
-
-        @Override
-        public boolean isUnsubscribed() {
-            return get() == null;
-        }
-
-        @Override
-        public void unsubscribe() {
-            if (get() != null) {
-                Cancellable c = getAndSet(null);
-                if (c != null) {
-                    try {
-                        c.cancel();
-                    } catch (Exception ex) {
-                        Exceptions.throwIfFatal(ex);
-                        RxJavaHooks.onError(ex);
-                    }
-                }
-            }
-        }
-    }
-
     static abstract class BaseEmitter<T>
     extends AtomicLong
     implements Emitter<T>, Producer, Subscription {
diff --git a/src/main/java/rx/internal/operators/SingleFromEmitter.java b/src/main/java/rx/internal/operators/SingleFromEmitter.java
new file mode 100644
index 0000000000..b87c90f054
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleFromEmitter.java
@@ -0,0 +1,118 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import rx.*;
+import rx.Single.OnSubscribe;
+import rx.exceptions.Exceptions;
+import rx.functions.*;
+import rx.internal.subscriptions.*;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Calls an action with a SingleEmitter instance for each individual subscribers that
+ * generates a terminal signal (eventually).
+ *
+ * @param <T> the success value type
+ */
+public final class SingleFromEmitter<T> implements OnSubscribe<T> {
+
+    final Action1<SingleEmitter<T>> producer;
+
+    public SingleFromEmitter(Action1<SingleEmitter<T>> producer) {
+        this.producer = producer;
+    }
+
+    @Override
+    public void call(SingleSubscriber<? super T> t) {
+        SingleEmitterImpl<T> parent = new SingleEmitterImpl<T>(t);
+        t.add(parent);
+
+        try {
+            producer.call(parent);
+        } catch (Throwable ex) {
+            Exceptions.throwIfFatal(ex);
+            parent.onError(ex);
+        }
+    }
+
+    static final class SingleEmitterImpl<T>
+    extends AtomicBoolean
+    implements SingleEmitter<T>, Subscription {
+        private static final long serialVersionUID = 8082834163465882809L;
+
+        final SingleSubscriber<? super T> actual;
+
+        final SequentialSubscription resource;
+
+        SingleEmitterImpl(SingleSubscriber<? super T> actual) {
+            this.actual = actual;
+            this.resource = new SequentialSubscription();
+        }
+
+        @Override
+        public void unsubscribe() {
+            if (compareAndSet(false, true)) {
+                resource.unsubscribe();
+            }
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return get();
+        }
+
+        @Override
+        public void onSuccess(T t) {
+            if (compareAndSet(false, true)) {
+                try {
+                    actual.onSuccess(t);
+                } finally {
+                    resource.unsubscribe();
+                }
+            }
+        }
+
+        @Override
+        public void onError(Throwable t) {
+            if (t == null) {
+                t = new NullPointerException();
+            }
+            if (compareAndSet(false, true)) {
+                try {
+                    actual.onError(t);
+                } finally {
+                    resource.unsubscribe();
+                }
+            } else {
+                RxJavaHooks.onError(t);
+            }
+        }
+
+        @Override
+        public void setSubscription(Subscription s) {
+            resource.update(s);
+        }
+
+        @Override
+        public void setCancellation(Cancellable c) {
+            setSubscription(new CancellableSubscription(c));
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/subscriptions/CancellableSubscription.java b/src/main/java/rx/internal/subscriptions/CancellableSubscription.java
new file mode 100644
index 0000000000..24c258b333
--- /dev/null
+++ b/src/main/java/rx/internal/subscriptions/CancellableSubscription.java
@@ -0,0 +1,43 @@
+package rx.internal.subscriptions;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import rx.Subscription;
+import rx.exceptions.Exceptions;
+import rx.functions.Cancellable;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * A Subscription that wraps an Cancellable instance.
+ */
+public final class CancellableSubscription
+extends AtomicReference<Cancellable>
+implements Subscription {
+
+    /** */
+    private static final long serialVersionUID = 5718521705281392066L;
+
+    public CancellableSubscription(Cancellable cancellable) {
+        super(cancellable);
+    }
+
+    @Override
+    public boolean isUnsubscribed() {
+        return get() == null;
+    }
+
+    @Override
+    public void unsubscribe() {
+        if (get() != null) {
+            Cancellable c = getAndSet(null);
+            if (c != null) {
+                try {
+                    c.cancel();
+                } catch (Exception ex) {
+                    Exceptions.throwIfFatal(ex);
+                    RxJavaHooks.onError(ex);
+                }
+            }
+        }
+    }
+}
diff --git a/src/test/java/rx/internal/operators/SingleFromEmitterTest.java b/src/test/java/rx/internal/operators/SingleFromEmitterTest.java
new file mode 100644
index 0000000000..a9f8dfd5b1
--- /dev/null
+++ b/src/test/java/rx/internal/operators/SingleFromEmitterTest.java
@@ -0,0 +1,221 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import static org.junit.Assert.*;
+
+import java.io.IOException;
+import java.util.*;
+
+import org.junit.*;
+
+import rx.*;
+import rx.exceptions.TestException;
+import rx.functions.*;
+import rx.observers.AssertableSubscriber;
+import rx.plugins.RxJavaHooks;
+
+public class SingleFromEmitterTest implements Cancellable, Action1<Throwable> {
+
+    int calls;
+
+    final List<Throwable> errors = Collections.synchronizedList(new ArrayList<Throwable>());
+
+    @Before
+    public void before() {
+        RxJavaHooks.setOnError(this);
+    }
+
+    @After
+    public void after() {
+        RxJavaHooks.reset();
+    }
+
+    @Override
+    public void cancel() throws Exception {
+        calls++;
+    }
+
+    @Override
+    public void call(Throwable t) {
+        errors.add(t);
+    }
+
+    @Test
+    public void normal() {
+        Single.fromEmitter(new Action1<SingleEmitter<Object>>() {
+            @Override
+            public void call(SingleEmitter<Object> e) {
+                e.setCancellation(SingleFromEmitterTest.this);
+                e.onSuccess(1);
+            }
+        })
+        .test()
+        .assertResult(1);
+
+        assertEquals(1, calls);
+    }
+
+    @Test
+    public void nullSuccess() {
+        Single.fromEmitter(new Action1<SingleEmitter<Object>>() {
+            @Override
+            public void call(SingleEmitter<Object> e) {
+                e.setCancellation(SingleFromEmitterTest.this);
+                e.onSuccess(null);
+            }
+        })
+        .test()
+        .assertResult((Object)null);
+
+        assertEquals(1, calls);
+    }
+
+    @Test
+    public void error() {
+        Single.fromEmitter(new Action1<SingleEmitter<Object>>() {
+            @Override
+            public void call(SingleEmitter<Object> e) {
+                e.setCancellation(SingleFromEmitterTest.this);
+                e.onError(new TestException());
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+
+        assertEquals(1, calls);
+    }
+
+    @Test
+    public void nullError() {
+        Single.fromEmitter(new Action1<SingleEmitter<Object>>() {
+            @Override
+            public void call(SingleEmitter<Object> e) {
+                e.setCancellation(SingleFromEmitterTest.this);
+                e.onError(null);
+            }
+        })
+        .test()
+        .assertFailure(NullPointerException.class);
+
+        assertEquals(1, calls);
+    }
+
+    @Test
+    public void crash() {
+        Single.fromEmitter(new Action1<SingleEmitter<Object>>() {
+            @Override
+            public void call(SingleEmitter<Object> e) {
+                e.setCancellation(SingleFromEmitterTest.this);
+                throw new TestException();
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+
+        assertEquals(1, calls);
+    }
+
+    @Test
+    public void crash2() {
+        Single.fromEmitter(new Action1<SingleEmitter<Object>>() {
+            @Override
+            public void call(SingleEmitter<Object> e) {
+                e.setCancellation(SingleFromEmitterTest.this);
+                e.onError(null);
+                throw new TestException();
+            }
+        })
+        .test()
+        .assertFailure(NullPointerException.class);
+
+        assertEquals(1, calls);
+
+        assertTrue(errors.get(0).toString(), errors.get(0) instanceof TestException);
+    }
+
+    @Test
+    public void unsubscribe() {
+        @SuppressWarnings("unchecked")
+        final SingleEmitter<Object>[] emitter = new SingleEmitter[1];
+
+        AssertableSubscriber<Object> ts = Single.fromEmitter(new Action1<SingleEmitter<Object>>() {
+            @Override
+            public void call(SingleEmitter<Object> e) {
+                emitter[0] = e;
+            }
+        })
+        .test();
+
+        ts.unsubscribe();
+
+        emitter[0].onSuccess(1);
+        emitter[0].onError(new TestException());
+
+        ts.assertNoErrors().assertNotCompleted().assertNoValues();
+
+        assertTrue(errors.get(0).toString(), errors.get(0) instanceof TestException);
+    }
+
+    @Test
+    public void onSuccessThrows() {
+        Single.fromEmitter(new Action1<SingleEmitter<Object>>() {
+            @Override
+            public void call(SingleEmitter<Object> e) {
+                e.setCancellation(SingleFromEmitterTest.this);
+                e.onSuccess(1);
+            }
+        })
+        .subscribe(new SingleSubscriber<Object>() {
+            @Override
+            public void onSuccess(Object value) {
+                throw new TestException();
+            }
+            @Override
+            public void onError(Throwable error) {
+            }
+        });
+
+        assertEquals(1, calls);
+
+        assertTrue(errors.get(0).toString(), errors.get(0) instanceof TestException);
+    }
+
+    @Test
+    public void onErrorThrows() {
+        Single.fromEmitter(new Action1<SingleEmitter<Object>>() {
+            @Override
+            public void call(SingleEmitter<Object> e) {
+                e.setCancellation(SingleFromEmitterTest.this);
+                e.onError(new IOException());
+            }
+        })
+        .subscribe(new SingleSubscriber<Object>() {
+            @Override
+            public void onSuccess(Object value) {
+            }
+            @Override
+            public void onError(Throwable error) {
+                throw new TestException();
+            }
+        });
+
+        assertEquals(1, calls);
+
+        assertTrue(errors.get(0).toString(), errors.get(0) instanceof TestException);
+    }
+}

From 8812756697358511843d73900bed69a125455dc1 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 15 Nov 2016 10:44:27 +0100
Subject: [PATCH 200/263] 1.x: Single::takeUntil CancellationException message
 enh.

---
 .../operators/SingleTakeUntilCompletable.java |  2 +-
 .../operators/SingleTakeUntilObservable.java  |  2 +-
 .../operators/SingleTakeUntilSingle.java      |  2 +-
 .../operators/SingleTakeUntilTest.java        | 61 +++++++++++++++++++
 4 files changed, 64 insertions(+), 3 deletions(-)
 create mode 100644 src/test/java/rx/internal/operators/SingleTakeUntilTest.java

diff --git a/src/main/java/rx/internal/operators/SingleTakeUntilCompletable.java b/src/main/java/rx/internal/operators/SingleTakeUntilCompletable.java
index 28110ade31..17111084e7 100644
--- a/src/main/java/rx/internal/operators/SingleTakeUntilCompletable.java
+++ b/src/main/java/rx/internal/operators/SingleTakeUntilCompletable.java
@@ -86,7 +86,7 @@ public void onError(Throwable error) {
 
         @Override
         public void onCompleted() {
-            onError(new CancellationException("Stream was canceled before emitting a terminal event."));
+            onError(new CancellationException("Single::takeUntil(Completable) - Stream was canceled before emitting a terminal event."));
         }
     }
 }
diff --git a/src/main/java/rx/internal/operators/SingleTakeUntilObservable.java b/src/main/java/rx/internal/operators/SingleTakeUntilObservable.java
index 81764449c4..604fda6f1f 100644
--- a/src/main/java/rx/internal/operators/SingleTakeUntilObservable.java
+++ b/src/main/java/rx/internal/operators/SingleTakeUntilObservable.java
@@ -96,7 +96,7 @@ public void onError(Throwable error) {
 
             @Override
             public void onCompleted() {
-                onError(new CancellationException("Stream was canceled before emitting a terminal event."));
+                onError(new CancellationException("Single::takeUntil(Observable) - Stream was canceled before emitting a terminal event."));
             }
         }
     }
diff --git a/src/main/java/rx/internal/operators/SingleTakeUntilSingle.java b/src/main/java/rx/internal/operators/SingleTakeUntilSingle.java
index 05dfc00efc..24c0439817 100644
--- a/src/main/java/rx/internal/operators/SingleTakeUntilSingle.java
+++ b/src/main/java/rx/internal/operators/SingleTakeUntilSingle.java
@@ -86,7 +86,7 @@ public void onError(Throwable error) {
         final class OtherSubscriber extends SingleSubscriber<U> {
             @Override
             public void onSuccess(U value) {
-                onError(new CancellationException("Stream was canceled before emitting a terminal event."));
+                onError(new CancellationException("Single::takeUntil(Single) - Stream was canceled before emitting a terminal event."));
             }
 
             @Override
diff --git a/src/test/java/rx/internal/operators/SingleTakeUntilTest.java b/src/test/java/rx/internal/operators/SingleTakeUntilTest.java
new file mode 100644
index 0000000000..45a9bb23db
--- /dev/null
+++ b/src/test/java/rx/internal/operators/SingleTakeUntilTest.java
@@ -0,0 +1,61 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.CancellationException;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+
+import rx.*;
+import rx.observers.AssertableSubscriber;
+
+public class SingleTakeUntilTest {
+
+    @Test
+    public void withSingleMessage() {
+        AssertableSubscriber<Integer> ts = Single.just(1).takeUntil(Single.just(2))
+        .test()
+        .assertFailure(CancellationException.class);
+
+        String message = ts.getOnErrorEvents().get(0).getMessage();
+
+        assertTrue(message, message.startsWith("Single::takeUntil(Single)"));
+    }
+
+    @Test
+    public void withCompletableMessage() {
+        AssertableSubscriber<Integer> ts = Single.just(1).takeUntil(Completable.complete())
+        .test()
+        .assertFailure(CancellationException.class);
+
+        String message = ts.getOnErrorEvents().get(0).getMessage();
+
+        assertTrue(message, message.startsWith("Single::takeUntil(Completable)"));
+    }
+
+    @Test
+    public void withObservableMessage() {
+        AssertableSubscriber<Integer> ts = Single.just(1).takeUntil(Observable.just(1))
+        .test()
+        .assertFailure(CancellationException.class);
+
+        String message = ts.getOnErrorEvents().get(0).getMessage();
+
+        assertTrue(message, message.startsWith("Single::takeUntil(Observable)"));
+    }
+}

From 8fff67d91f4d4740c0b1fa55ba238249242f2bb2 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 23 Nov 2016 09:42:10 +0100
Subject: [PATCH 201/263] Release 1.2.3

---
 CHANGES.md | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 1741085701..86551b818d 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,28 @@
 # RxJava Releases #
 
+### Version 1.2.3 - November 23, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.3%7C))
+
+#### Documentation enhancements
+
+- [Pull 4846](https://github.com/ReactiveX/RxJava/pull/4846): Specify the system parameters configuring the schedulers in the `Schedulers` javadoc.
+
+#### API enhancements
+
+- [Pull 4777](https://github.com/ReactiveX/RxJava/pull/4777): add `AssertableSubscriber` to provide method chained version of `TestSubscriber` and support a `test()` method on the base reactive classes.
+- [Pull 4851](https://github.com/ReactiveX/RxJava/pull/4851): add `Single.fromEmitter`
+- [Pull 4852](https://github.com/ReactiveX/RxJava/pull/4852): `Single.takeUntil` `CancellationException` message enhancements
+
+#### Performance enhancements
+
+- [Pull 4846](https://github.com/ReactiveX/RxJava/pull/4846): remove ObjectPool, code style cleanups
+
+#### Bugfixes
+
+- [Pull 4826](https://github.com/ReactiveX/RxJava/pull/4826):   `Schedule.when()` bug fix
+- [Pull 4830](https://github.com/ReactiveX/RxJava/pull/4830): `Completable.doAfterTerminate` to run after `onError` as well.
+- [Pull 4841](https://github.com/ReactiveX/RxJava/pull/4841): replace non-serializable value of `OnNextValue` with its `toString`.
+- [Pull 4849](https://github.com/ReactiveX/RxJava/pull/4849): fix `Completable.concat` & `merge` hanging in async situations.
+
 ### Version 1.2.2 - November 3, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.2%7C))
 
 Note that the interface `Cancellable` has been moved to `rx.functions` affecting `CompletableEmitter` and  the experimental `Observable.fromEmitter(Action1<AsyncEmitter<T>> emitter, AsyncEmitter.BackpressureMode backpressure)` has been removed.

From a606a26cc2fb9f7f313ef8104b342a96c378c054 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Mon, 28 Nov 2016 09:07:53 +0100
Subject: [PATCH 202/263] 1.x: enable TestScheduler with nanosecond periodic
 scheduling (#4884)

---
 src/main/java/rx/Scheduler.java               |  58 +---------
 .../schedulers/SchedulePeriodicHelper.java    | 102 ++++++++++++++++++
 .../java/rx/schedulers/TestScheduler.java     |  15 ++-
 src/test/java/rx/SchedulerWorkerTest.java     |   5 +-
 .../java/rx/schedulers/TestSchedulerTest.java |  37 ++++---
 5 files changed, 147 insertions(+), 70 deletions(-)
 create mode 100644 src/main/java/rx/internal/schedulers/SchedulePeriodicHelper.java

diff --git a/src/main/java/rx/Scheduler.java b/src/main/java/rx/Scheduler.java
index bbcd19ae34..b98615ff47 100644
--- a/src/main/java/rx/Scheduler.java
+++ b/src/main/java/rx/Scheduler.java
@@ -19,8 +19,7 @@
 
 import rx.annotations.Experimental;
 import rx.functions.*;
-import rx.internal.schedulers.SchedulerWhen;
-import rx.internal.subscriptions.SequentialSubscription;
+import rx.internal.schedulers.*;
 import rx.schedulers.Schedulers;
 
 /**
@@ -44,18 +43,6 @@ public abstract class Scheduler {
  *  : Without virtual extension methods even additive changes are breaking and thus severely impede library
  *    maintenance.
  */
-
-    /**
-     * The tolerance for a clock drift in nanoseconds where the periodic scheduler will rebase.
-     * <p>
-     * The associated system parameter, {@code rx.scheduler.drift-tolerance}, expects its value in minutes.
-     */
-    static final long CLOCK_DRIFT_TOLERANCE_NANOS;
-    static {
-        CLOCK_DRIFT_TOLERANCE_NANOS = TimeUnit.MINUTES.toNanos(
-                Long.getLong("rx.scheduler.drift-tolerance", 15));
-    }
-
     /**
      * Retrieves or creates a new {@link Scheduler.Worker} that represents serial execution of actions.
      * <p>
@@ -121,47 +108,8 @@ public abstract static class Worker implements Subscription {
          * @return a subscription to be able to prevent or cancel the execution of the action
          */
         public Subscription schedulePeriodically(final Action0 action, long initialDelay, long period, TimeUnit unit) {
-            final long periodInNanos = unit.toNanos(period);
-            final long firstNowNanos = TimeUnit.MILLISECONDS.toNanos(now());
-            final long firstStartInNanos = firstNowNanos + unit.toNanos(initialDelay);
-
-            final SequentialSubscription first = new SequentialSubscription();
-            final SequentialSubscription mas = new SequentialSubscription(first);
-
-            final Action0 recursiveAction = new Action0() {
-                long count;
-                long lastNowNanos = firstNowNanos;
-                long startInNanos = firstStartInNanos;
-                @Override
-                public void call() {
-                    action.call();
-
-                    if (!mas.isUnsubscribed()) {
-
-                        long nextTick;
-
-                        long nowNanos = TimeUnit.MILLISECONDS.toNanos(now());
-                        // If the clock moved in a direction quite a bit, rebase the repetition period
-                        if (nowNanos + CLOCK_DRIFT_TOLERANCE_NANOS < lastNowNanos
-                                || nowNanos >= lastNowNanos + periodInNanos + CLOCK_DRIFT_TOLERANCE_NANOS) {
-                            nextTick = nowNanos + periodInNanos;
-                            /*
-                             * Shift the start point back by the drift as if the whole thing
-                             * started count periods ago.
-                             */
-                            startInNanos = nextTick - (periodInNanos * (++count));
-                        } else {
-                            nextTick = startInNanos + (++count * periodInNanos);
-                        }
-                        lastNowNanos = nowNanos;
-
-                        long delay = nextTick - nowNanos;
-                        mas.replace(schedule(this, delay, TimeUnit.NANOSECONDS));
-                    }
-                }
-            };
-            first.replace(schedule(recursiveAction, initialDelay, unit));
-            return mas;
+            return SchedulePeriodicHelper.schedulePeriodically(this, action,
+                    initialDelay, period, unit, null);
         }
 
         /**
diff --git a/src/main/java/rx/internal/schedulers/SchedulePeriodicHelper.java b/src/main/java/rx/internal/schedulers/SchedulePeriodicHelper.java
new file mode 100644
index 0000000000..4ca7b74941
--- /dev/null
+++ b/src/main/java/rx/internal/schedulers/SchedulePeriodicHelper.java
@@ -0,0 +1,102 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.schedulers;
+
+import java.util.concurrent.TimeUnit;
+
+import rx.Scheduler.Worker;
+import rx.Subscription;
+import rx.functions.Action0;
+import rx.internal.subscriptions.SequentialSubscription;
+
+/**
+ * Utility method for scheduling tasks periodically (at a fixed rate) by using Worker.schedule(Action0, long, TimeUnit).
+ */
+public final class SchedulePeriodicHelper {
+
+    /** Utility class. */
+    private SchedulePeriodicHelper() {
+        throw new IllegalStateException("No instances!");
+    }
+
+    /**
+     * The tolerance for a clock drift in nanoseconds where the periodic scheduler will rebase.
+     * <p>
+     * The associated system parameter, {@code rx.scheduler.drift-tolerance}, expects its value in minutes.
+     */
+    public static final long CLOCK_DRIFT_TOLERANCE_NANOS;
+    static {
+        CLOCK_DRIFT_TOLERANCE_NANOS = TimeUnit.MINUTES.toNanos(
+                Long.getLong("rx.scheduler.drift-tolerance", 15));
+    }
+
+    /**
+     * Return the current time in nanoseconds. 
+     */
+    public interface NowNanoSupplier {
+        long nowNanos();
+    }
+
+    public static Subscription schedulePeriodically(
+            final Worker worker,
+            final Action0 action, 
+            long initialDelay, long period, TimeUnit unit,
+            final NowNanoSupplier nowNanoSupplier) {
+        final long periodInNanos = unit.toNanos(period);
+        final long firstNowNanos = nowNanoSupplier != null ? nowNanoSupplier.nowNanos() : TimeUnit.MILLISECONDS.toNanos(worker.now());
+        final long firstStartInNanos = firstNowNanos + unit.toNanos(initialDelay);
+
+        final SequentialSubscription first = new SequentialSubscription();
+        final SequentialSubscription mas = new SequentialSubscription(first);
+
+        final Action0 recursiveAction = new Action0() {
+            long count;
+            long lastNowNanos = firstNowNanos;
+            long startInNanos = firstStartInNanos;
+            @Override
+            public void call() {
+                action.call();
+
+                if (!mas.isUnsubscribed()) {
+
+                    long nextTick;
+
+                    long nowNanos = nowNanoSupplier != null ? nowNanoSupplier.nowNanos() : TimeUnit.MILLISECONDS.toNanos(worker.now());
+                    // If the clock moved in a direction quite a bit, rebase the repetition period
+                    if (nowNanos + CLOCK_DRIFT_TOLERANCE_NANOS < lastNowNanos
+                            || nowNanos >= lastNowNanos + periodInNanos + CLOCK_DRIFT_TOLERANCE_NANOS) {
+                        nextTick = nowNanos + periodInNanos;
+                        /*
+                         * Shift the start point back by the drift as if the whole thing
+                         * started count periods ago.
+                         */
+                        startInNanos = nextTick - (periodInNanos * (++count));
+                    } else {
+                        nextTick = startInNanos + (++count * periodInNanos);
+                    }
+                    lastNowNanos = nowNanos;
+
+                    long delay = nextTick - nowNanos;
+                    mas.replace(worker.schedule(this, delay, TimeUnit.NANOSECONDS));
+                }
+            }
+        };
+        first.replace(worker.schedule(recursiveAction, initialDelay, unit));
+        return mas;
+    }
+
+}
diff --git a/src/main/java/rx/schedulers/TestScheduler.java b/src/main/java/rx/schedulers/TestScheduler.java
index f540569b19..89717914c9 100644
--- a/src/main/java/rx/schedulers/TestScheduler.java
+++ b/src/main/java/rx/schedulers/TestScheduler.java
@@ -23,6 +23,8 @@
 import rx.Scheduler;
 import rx.Subscription;
 import rx.functions.Action0;
+import rx.internal.schedulers.SchedulePeriodicHelper;
+import rx.internal.schedulers.SchedulePeriodicHelper.NowNanoSupplier;
 import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.Subscriptions;
 
@@ -130,7 +132,7 @@ public Worker createWorker() {
         return new InnerTestScheduler();
     }
 
-    final class InnerTestScheduler extends Worker {
+    final class InnerTestScheduler extends Worker implements NowNanoSupplier {
 
         private final BooleanSubscription s = new BooleanSubscription();
 
@@ -172,10 +174,21 @@ public void call() {
             });
         }
 
+        @Override
+        public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) {
+            return SchedulePeriodicHelper.schedulePeriodically(this, 
+                    action, initialDelay, period, unit, this);
+        }
+        
         @Override
         public long now() {
             return TestScheduler.this.now();
         }
+        
+        @Override
+        public long nowNanos() {
+            return TestScheduler.this.time;
+        }
 
     }
 
diff --git a/src/test/java/rx/SchedulerWorkerTest.java b/src/test/java/rx/SchedulerWorkerTest.java
index 16d0c65553..159d3d34a7 100644
--- a/src/test/java/rx/SchedulerWorkerTest.java
+++ b/src/test/java/rx/SchedulerWorkerTest.java
@@ -23,6 +23,7 @@
 import org.junit.Test;
 
 import rx.functions.Action0;
+import rx.internal.schedulers.SchedulePeriodicHelper;
 import rx.schedulers.Schedulers;
 
 public class SchedulerWorkerTest {
@@ -85,7 +86,7 @@ public void call() {
 
             Thread.sleep(150);
 
-            s.drift = -1000 - TimeUnit.NANOSECONDS.toMillis(Scheduler.CLOCK_DRIFT_TOLERANCE_NANOS);
+            s.drift = -1000 - TimeUnit.NANOSECONDS.toMillis(SchedulePeriodicHelper.CLOCK_DRIFT_TOLERANCE_NANOS);
 
             Thread.sleep(400);
 
@@ -127,7 +128,7 @@ public void call() {
 
             Thread.sleep(150);
 
-            s.drift = 1000 + TimeUnit.NANOSECONDS.toMillis(Scheduler.CLOCK_DRIFT_TOLERANCE_NANOS);
+            s.drift = 1000 + TimeUnit.NANOSECONDS.toMillis(SchedulePeriodicHelper.CLOCK_DRIFT_TOLERANCE_NANOS);
 
             Thread.sleep(400);
 
diff --git a/src/test/java/rx/schedulers/TestSchedulerTest.java b/src/test/java/rx/schedulers/TestSchedulerTest.java
index ba95fd1df9..18e3e46913 100644
--- a/src/test/java/rx/schedulers/TestSchedulerTest.java
+++ b/src/test/java/rx/schedulers/TestSchedulerTest.java
@@ -17,25 +17,18 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Matchers.anyLong;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Mockito;
+import org.mockito.*;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.functions.Func1;
+import rx.functions.*;
+import rx.observers.TestSubscriber;
 
 public class TestSchedulerTest {
 
@@ -222,4 +215,24 @@ public void call() {
             inner.unsubscribe();
         }
     }
+    
+    @Test
+    public void resolution() {
+        for (final TimeUnit unit : TimeUnit.values()) {
+            TestScheduler scheduler = new TestScheduler();
+            TestSubscriber<String> testSubscriber = new TestSubscriber<String>();
+
+            Observable.interval(30, unit, scheduler)
+            .map(new Func1<Long, String>() {
+                @Override
+                public String call(Long v) {
+                    return v + "-" + unit;
+                }
+            })
+            .subscribe(testSubscriber);
+            scheduler.advanceTimeTo(60, unit);
+
+            testSubscriber.assertValues("0-" + unit, "1-" + unit);
+        }
+    }
 }

From 4c51531b88c481087ff7d264c129818c682fe3c2 Mon Sep 17 00:00:00 2001
From: chanx2 <chanx2@users.noreply.github.com>
Date: Mon, 28 Nov 2016 20:14:19 +0800
Subject: [PATCH 203/263] Update CHANGES.md (#4892)

fix URL typo
---
 CHANGES.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGES.md b/CHANGES.md
index 86551b818d..5ae3df64cb 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -273,7 +273,7 @@ This release contains mostly internal cleanups, reinforced Observable-protocol a
 
 #### Bugfixes
 
-  - [Pull 4231](https://github.com/ReactiveX/RxJava/pull/4213): `Schedulers.io()` workers now wait until a blocking task finishes before becoming available again.
+  - [Pull 4231](https://github.com/ReactiveX/RxJava/pull/4231): `Schedulers.io()` workers now wait until a blocking task finishes before becoming available again.
   - [Pull 4244](https://github.com/ReactiveX/RxJava/pull/4244): Fix `all` multiple terminal events.
   - [Pull 4241](https://github.com/ReactiveX/RxJava/pull/4241): Fix reentrancy bug in `repeatWhen` and `retryWhen` when the resubscription happens.
   - [Pull 4225](https://github.com/ReactiveX/RxJava/pull/4225): `PublishSubject` now checks for unsubscribed child while dispatching events.

From 0b37a7e1c2f2415e86c24474239535dcac009cce Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Mon, 28 Nov 2016 15:41:00 +0100
Subject: [PATCH 204/263] 1.x: add Issue and PR "welcome" templates (#4890)

---
 .github/ISSUE_TEMPLATE.md        | 13 +++++++++++++
 .github/PULL_REQUEST_TEMPLATE.md |  7 +++++++
 2 files changed, 20 insertions(+)
 create mode 100644 .github/ISSUE_TEMPLATE.md
 create mode 100644 .github/PULL_REQUEST_TEMPLATE.md

diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
new file mode 100644
index 0000000000..62ab68a18e
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE.md
@@ -0,0 +1,13 @@
+Thanks for using RxJava but before you post an issue, please consider the following points:
+
+  - [ ] Please include the library version number, including the minor and patch version, in the issue text. In addition, if you'd include the major version in the title (such as `2.x`) that would be great.
+
+  - [ ] If you think you found a bug, please include a code sample that reproduces the problem. Dumping a stacktrace is usually not enough for us.
+
+  - [ ] RxJava has more than 150 operators, we recommend searching the [javadoc](http://reactivex.io/RxJava/1.x/javadoc/rx/Observable.html) for keywords of what you try to accomplish.
+
+  - [ ] If you have a question/issue about a library/technology built on top of RxJava (such as Retrofit, RxNetty, etc.), please consider asking a question on StackOverflow first (then maybe on their issue list).
+
+  - [ ] Questions like "how do I X with RxJava" are generally better suited for StackOverflow (where it may already have an answer).
+
+  - [ ] Please avoid cross-posting questions on StackOverflow, this issue list, the Gitter room or the mailing list.
\ No newline at end of file
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 0000000000..885315565f
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,7 @@
+Thank you for contributing to RxJava. Before pressing the "Create Pull Request" button, please consider the following points:
+
+  - [ ] Please give a description about what and why you are contributing, even if it's trivial.
+
+  - [ ] Please include the issue list number(s) or other PR numbers in the description if you are contributing in response to those.
+
+  - [ ] Please include a reasonable set of unit tests if you contribute new code or change an existing one. If you contribute an operator, (if applicable) please make sure you have tests for working with an `empty`, `just`, `range` of values as well as an `error` source, with and/or without backpressure and see if unsubscription/cancellation propagates correctly.

From 57a9c09960933ce231e401d9e10bb615da2a8f79 Mon Sep 17 00:00:00 2001
From: John <jawnnypoo@gmail.com>
Date: Wed, 7 Dec 2016 01:53:50 -0600
Subject: [PATCH 205/263] Use t instead of value to allow for IDE naming
 (#4908)

---
 src/main/java/rx/SingleSubscriber.java         | 4 ++--
 src/main/java/rx/observers/SafeSubscriber.java | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/main/java/rx/SingleSubscriber.java b/src/main/java/rx/SingleSubscriber.java
index 53e9a70faa..0860dd331f 100644
--- a/src/main/java/rx/SingleSubscriber.java
+++ b/src/main/java/rx/SingleSubscriber.java
@@ -43,10 +43,10 @@ public abstract class SingleSubscriber<T> implements Subscription {
      * <p>
      * The {@link Single} will not call this method if it calls {@link #onError}.
      *
-     * @param value
+     * @param t
      *          the item emitted by the Single
      */
-    public abstract void onSuccess(T value);
+    public abstract void onSuccess(T t);
 
     /**
      * Notifies the SingleSubscriber that the {@link Single} has experienced an error condition.
diff --git a/src/main/java/rx/observers/SafeSubscriber.java b/src/main/java/rx/observers/SafeSubscriber.java
index 717946c032..16027b0d52 100644
--- a/src/main/java/rx/observers/SafeSubscriber.java
+++ b/src/main/java/rx/observers/SafeSubscriber.java
@@ -124,14 +124,14 @@ public void onError(Throwable e) {
      * The {@code Observable} will not call this method again after it calls either {@link #onCompleted} or
      * {@link #onError}.
      *
-     * @param args
+     * @param t
      *          the item emitted by the Observable
      */
     @Override
-    public void onNext(T args) {
+    public void onNext(T t) {
         try {
             if (!done) {
-                actual.onNext(args);
+                actual.onNext(t);
             }
         } catch (Throwable e) {
             // we handle here instead of another method so we don't add stacks to the frame

From 7c7c9b919db9f1a32a30fc5bc0648e1f7cd3f912 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A9sar=20Puerta?= <cesar1000@users.noreply.github.com>
Date: Fri, 9 Dec 2016 09:03:19 -0800
Subject: [PATCH 206/263] Fix resolveAndroidApiVersion when running under
 Robolectric (#4912)

PlatformDependent.resolveAndroidApiVersion() tries to determine the
Android SDK version by reading the android.os.Build$VERSION#SDK_INT
field. When running under Robolectric, the class will be found (since
Robolectric bundles an original android.jar). However, the method is
using the system class loader for loading it (instead of the Robolectric
instrumenting class loader), which will not instrument the class to run
in the JVM. As a result, static initialization of the class fails with
an UnsatisfiedLinkError when calling SystemProperties.get(), which calls
native method native_get.

I fixed by using the default class loader instead. This would only make
a difference in the extremely rare case that the Android application
installs a class loader that's not capable of finding Android classes.
I tested that this behaves as expected on a device, fixes the issue
with Robolectric, and detects it's not Android otherwise (as proven
by the unit test).
---
 .../rx/internal/util/PlatformDependent.java   | 21 +------------------
 .../internal/util/PlatformDependentTest.java  |  9 ++++++++
 2 files changed, 10 insertions(+), 20 deletions(-)

diff --git a/src/main/java/rx/internal/util/PlatformDependent.java b/src/main/java/rx/internal/util/PlatformDependent.java
index 1a48e8067b..2b6d5c6e65 100644
--- a/src/main/java/rx/internal/util/PlatformDependent.java
+++ b/src/main/java/rx/internal/util/PlatformDependent.java
@@ -15,9 +15,6 @@
  */
 package rx.internal.util;
 
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-
 /**
  * Allow platform dependent logic such as checks for Android.
  *
@@ -67,7 +64,7 @@ public static int getAndroidApiVersion() {
     private static int resolveAndroidApiVersion() {
         try {
             return (Integer) Class
-                    .forName("android.os.Build$VERSION", true, getSystemClassLoader())
+                    .forName("android.os.Build$VERSION")
                     .getField("SDK_INT")
                     .get(null);
         } catch (Exception e) { // NOPMD
@@ -76,20 +73,4 @@ private static int resolveAndroidApiVersion() {
             return ANDROID_API_VERSION_IS_NOT_ANDROID;
         }
     }
-
-    /**
-     * Return the system {@link ClassLoader}.
-     */
-    static ClassLoader getSystemClassLoader() {
-        if (System.getSecurityManager() == null) {
-            return ClassLoader.getSystemClassLoader();
-        } else {
-            return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
-                @Override
-                public ClassLoader run() {
-                    return ClassLoader.getSystemClassLoader();
-                }
-            });
-        }
-    }
 }
diff --git a/src/test/java/rx/internal/util/PlatformDependentTest.java b/src/test/java/rx/internal/util/PlatformDependentTest.java
index 64f47915b1..b868145a83 100644
--- a/src/test/java/rx/internal/util/PlatformDependentTest.java
+++ b/src/test/java/rx/internal/util/PlatformDependentTest.java
@@ -19,9 +19,18 @@
 
 import rx.TestUtil;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
 public class PlatformDependentTest {
     @Test
     public void constructorShouldBePrivate() {
         TestUtil.checkUtilityClass(PlatformDependent.class);
     }
+
+    @Test
+    public void platformShouldNotBeAndroid() {
+        assertFalse(PlatformDependent.isAndroid());
+        assertEquals(0, PlatformDependent.getAndroidApiVersion());
+    }
 }

From 4406bcb672b7e8e31830ba313e5bd7ebbaf3063a Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 15 Dec 2016 12:47:31 +0100
Subject: [PATCH 207/263] Release 1.2.4

---
 CHANGES.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 5ae3df64cb..f0558e3d6f 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,13 @@
 # RxJava Releases #
 
+### Version 1.2.4 - December 15, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.4%7C))
+
+#### Other
+
+- [Pull 4912](https://github.com/ReactiveX/RxJava/pull/4912): Fix `resolveAndroidApiVersion` when running under Robolectric
+- [Pull 4908](https://github.com/ReactiveX/RxJava/pull/4908): Use `t` instead of value to allow for IDE naming.
+- [Pull 4884](https://github.com/ReactiveX/RxJava/pull/4884): enable `TestScheduler` with nanosecond periodic scheduling
+
 ### Version 1.2.3 - November 23, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.3%7C))
 
 #### Documentation enhancements

From 6de5c6fff60684e29e00b43e5f493884e8801393 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 28 Dec 2016 22:03:44 +0100
Subject: [PATCH 208/263] 1.x: Completable.mergeDelayError check unsafe
 availability (#4941)

---
 ...CompletableOnSubscribeMergeDelayErrorIterable.java | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
index 20477e64fd..0c8f5bafee 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeMergeDelayErrorIterable.java
@@ -21,7 +21,8 @@
 
 import rx.*;
 import rx.Completable.OnSubscribe;
-import rx.internal.util.unsafe.MpscLinkedQueue;
+import rx.internal.util.atomic.MpscLinkedAtomicQueue;
+import rx.internal.util.unsafe.*;
 import rx.subscriptions.CompositeSubscription;
 
 public final class CompletableOnSubscribeMergeDelayErrorIterable implements OnSubscribe {
@@ -53,7 +54,13 @@ public void call(final CompletableSubscriber s) {
 
         final AtomicInteger wip = new AtomicInteger(1);
 
-        final Queue<Throwable> queue = new MpscLinkedQueue<Throwable>();
+        final Queue<Throwable> queue;
+
+        if (UnsafeAccess.isUnsafeAvailable()) {
+            queue = new MpscLinkedQueue<Throwable>();
+        } else {
+            queue = new MpscLinkedAtomicQueue<Throwable>();
+        }
 
         for (;;) {
             if (set.isUnsubscribed()) {

From eaf146a390fab0bf6a80a533229bbf4aa8ebe100 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 30 Dec 2016 16:20:25 +0100
Subject: [PATCH 209/263] 1.x: header and whitespace cleanup (#4949)

---
 .../schedulers/SchedulePeriodicHelper.java       |  4 ++--
 .../subscriptions/CancellableSubscription.java   | 16 ++++++++++++++++
 src/main/java/rx/schedulers/TestScheduler.java   |  6 +++---
 .../operators/CompletableConcatTest.java         | 16 ++++++++++++++++
 .../internal/operators/CompletableMergeTest.java | 16 ++++++++++++++++
 .../java/rx/schedulers/TestSchedulerTest.java    |  2 +-
 6 files changed, 54 insertions(+), 6 deletions(-)

diff --git a/src/main/java/rx/internal/schedulers/SchedulePeriodicHelper.java b/src/main/java/rx/internal/schedulers/SchedulePeriodicHelper.java
index 4ca7b74941..e11e072c0a 100644
--- a/src/main/java/rx/internal/schedulers/SchedulePeriodicHelper.java
+++ b/src/main/java/rx/internal/schedulers/SchedulePeriodicHelper.java
@@ -45,7 +45,7 @@ private SchedulePeriodicHelper() {
     }
 
     /**
-     * Return the current time in nanoseconds. 
+     * Return the current time in nanoseconds.
      */
     public interface NowNanoSupplier {
         long nowNanos();
@@ -53,7 +53,7 @@ public interface NowNanoSupplier {
 
     public static Subscription schedulePeriodically(
             final Worker worker,
-            final Action0 action, 
+            final Action0 action,
             long initialDelay, long period, TimeUnit unit,
             final NowNanoSupplier nowNanoSupplier) {
         final long periodInNanos = unit.toNanos(period);
diff --git a/src/main/java/rx/internal/subscriptions/CancellableSubscription.java b/src/main/java/rx/internal/subscriptions/CancellableSubscription.java
index 24c258b333..dcfd1bd075 100644
--- a/src/main/java/rx/internal/subscriptions/CancellableSubscription.java
+++ b/src/main/java/rx/internal/subscriptions/CancellableSubscription.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.subscriptions;
 
 import java.util.concurrent.atomic.AtomicReference;
diff --git a/src/main/java/rx/schedulers/TestScheduler.java b/src/main/java/rx/schedulers/TestScheduler.java
index 89717914c9..0106cdbc67 100644
--- a/src/main/java/rx/schedulers/TestScheduler.java
+++ b/src/main/java/rx/schedulers/TestScheduler.java
@@ -176,15 +176,15 @@ public void call() {
 
         @Override
         public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit) {
-            return SchedulePeriodicHelper.schedulePeriodically(this, 
+            return SchedulePeriodicHelper.schedulePeriodically(this,
                     action, initialDelay, period, unit, this);
         }
-        
+
         @Override
         public long now() {
             return TestScheduler.this.now();
         }
-        
+
         @Override
         public long nowNanos() {
             return TestScheduler.this.time;
diff --git a/src/test/java/rx/internal/operators/CompletableConcatTest.java b/src/test/java/rx/internal/operators/CompletableConcatTest.java
index 7ce2529322..d05b11fc45 100644
--- a/src/test/java/rx/internal/operators/CompletableConcatTest.java
+++ b/src/test/java/rx/internal/operators/CompletableConcatTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import java.util.concurrent.TimeUnit;
diff --git a/src/test/java/rx/internal/operators/CompletableMergeTest.java b/src/test/java/rx/internal/operators/CompletableMergeTest.java
index 790d51d5f4..a16518ab36 100644
--- a/src/test/java/rx/internal/operators/CompletableMergeTest.java
+++ b/src/test/java/rx/internal/operators/CompletableMergeTest.java
@@ -1,3 +1,19 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
 
 import java.util.concurrent.TimeUnit;
diff --git a/src/test/java/rx/schedulers/TestSchedulerTest.java b/src/test/java/rx/schedulers/TestSchedulerTest.java
index 18e3e46913..6c7b76e28e 100644
--- a/src/test/java/rx/schedulers/TestSchedulerTest.java
+++ b/src/test/java/rx/schedulers/TestSchedulerTest.java
@@ -215,7 +215,7 @@ public void call() {
             inner.unsubscribe();
         }
     }
-    
+
     @Test
     public void resolution() {
         for (final TimeUnit unit : TimeUnit.values()) {

From b9c7f0ba94de070c9b0823e0c2b190ad09f3c5ac Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 6 Jan 2017 12:52:32 +0100
Subject: [PATCH 210/263] 1.x: add missing marbles, fix image sizes (#4963)

---
 src/main/java/rx/Observable.java | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 434cbd22e8..cdc03e518e 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -111,7 +111,7 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
      * {@link Observable#create(AsyncOnSubscribe) asynchronous overload}.
      *
      * <p>
-     * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/create-sync.png" alt="">
+     * <img width="527" height="262" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/create-sync.png" alt="">
      * <p>
      * See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed
      * information.
@@ -153,7 +153,7 @@ public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe)
      * with the {@link Observable#create(SyncOnSubscribe) synchronous overload}.
      *
      * <p>
-     * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/create-async.png" alt="">
+     * <img width="527" height="262" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/create-async.png" alt="">
      * <p>
      * See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed
      * information.
@@ -323,7 +323,7 @@ public Single<T> toSingle() {
      * {@code ignoreAllElements()}) and calls onCompleted when this source observable calls
      * onCompleted. Error terminal events are propagated.
      * <p>
-     * <img width="640" height="295" src=
+     * <img width="470" height="176" src=
      * "https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Completable.toCompletable.png"
      * alt="">
      * <dl>
@@ -5390,6 +5390,8 @@ public final Observable<T> defaultIfEmpty(final T defaultValue) {
      * Returns an Observable that emits the items emitted by the source Observable or the items of an alternate
      * Observable if the source Observable is empty.
      * <p/>
+     * <p>
+     * <img width="410" height="164" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/switchifempty.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>If the source {@code Observable} is empty, the alternate {@code Observable} is expected to honor backpressure.

From 371674746dc4136bf74515962edf52e21ca7d420 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 6 Jan 2017 12:52:56 +0100
Subject: [PATCH 211/263] Release 1.2.5

---
 CHANGES.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index f0558e3d6f..9ec1cae969 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,15 @@
 # RxJava Releases #
 
+### Version 1.2.5 - January 6, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.5%7C))
+
+#### Documentation
+
+- [Pull 4963](https://github.com/ReactiveX/RxJava/pull/4963): Add missing marbles, fix image sizes
+
+#### Bugfixes
+
+- [Pull 4941](https://github.com/ReactiveX/RxJava/pull/4941): Fix `Completable.mergeDelayError` to check unsafe availability
+
 ### Version 1.2.4 - December 15, 2016 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.4%7C))
 
 #### Other

From 9f025638a2fb8e2579a1af5490ef2f608f81414d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Brais=20Gab=C3=ADn?= <braisgabin@gmail.com>
Date: Tue, 17 Jan 2017 13:35:54 +0100
Subject: [PATCH 212/263] Add which are the other stardard methods of create
 (#5000)

---
 src/main/java/rx/Observable.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index cdc03e518e..b00fea5bea 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -63,7 +63,7 @@ protected Observable(OnSubscribe<T> f) {
 
     /**
      * <strong>This method requires advanced knowledge about building operators and data sources; please consider
-     * other standard methods first;</strong>
+     * other standard methods first, such as {@link Observable#fromEmitter(Action1, Emitter.BackpressureMode)};</strong>
      * Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to
      * it.
      * <p>

From 56d94b2d6dfbb54fb6c1c0d8ab0e04659ff05f0b Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 24 Jan 2017 12:32:01 +0100
Subject: [PATCH 213/263] 1.x: update sample(time) diagram to indicate emission
 of last (#5007)

---
 src/main/java/rx/Observable.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index b00fea5bea..67e4d6149e 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -9100,7 +9100,7 @@ public final Observable<T> retryWhen(final Func1<? super Observable<? extends Th
      * Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable
      * within periodic time intervals.
      * <p>
-     * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/sample.png" alt="">
+     * <img width="640" height="276" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/sample.emitlast.1x.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>
@@ -9126,7 +9126,7 @@ public final Observable<T> sample(long period, TimeUnit unit) {
      * Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable
      * within periodic time intervals, where the intervals are defined on a particular Scheduler.
      * <p>
-     * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/sample.s.png" alt="">
+     * <img width="640" height="276" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/sample.s.emitlast.1x.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
      *  <dd>This operator does not support backpressure as it uses time to control data flow.</dd>

From 748b56dfd0a14c41890f891e53d02c5dc87d5e8b Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 28 Jan 2017 19:17:30 +0100
Subject: [PATCH 214/263] 1.x: fix groupBy consuming the upstream in an
 unbounded manner (#5030)

---
 .../internal/operators/OperatorGroupBy.java   | 11 ++++---
 .../operators/OperatorGroupByTest.java        | 30 +++++++++++++++++++
 2 files changed, 35 insertions(+), 6 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index af2fd4347a..8892f0d4d0 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -202,7 +202,7 @@ public void onNext(T t) {
                 return;
             }
 
-            boolean notNew = true;
+            boolean newGroup = false;
             Object mapKey = key != null ? key : NULL_KEY;
             GroupedUnicast<K, V> group = groups.get(mapKey);
             if (group == null) {
@@ -214,9 +214,7 @@ public void onNext(T t) {
 
                     groupCount.getAndIncrement();
 
-                    notNew = false;
-                    q.offer(group);
-                    drain();
+                    newGroup = true;
                 } else {
                     return;
                 }
@@ -243,8 +241,9 @@ public void onNext(T t) {
                 }
             }
 
-            if (notNew) {
-                s.request(1);
+            if (newGroup) {
+                q.offer(group);
+                drain();
             }
         }
 
diff --git a/src/test/java/rx/internal/operators/OperatorGroupByTest.java b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
index 2d90e6f29a..1cad5330c3 100644
--- a/src/test/java/rx/internal/operators/OperatorGroupByTest.java
+++ b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
@@ -2017,4 +2017,34 @@ public Map<Integer, Object> call(Action1<Integer> t) {
                 throw exception;
             }};
     }
+    
+    @Test
+    public void outerConsumedInABoundedManner() {
+        final int[] counter = { 0 };
+        
+        Observable.range(1, 10000)
+        .doOnRequest(new Action1<Long>() {
+            @Override
+            public void call(Long v) {
+                counter[0] += v;
+            }
+        })
+        .groupBy(new Func1<Integer, Integer>() {
+            @Override
+            public Integer call(Integer v) {
+                return 1;
+            }
+        })
+        .flatMap(new Func1<GroupedObservable<Integer, Integer>, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(GroupedObservable<Integer, Integer> v) {
+                return v;
+            }
+        })
+        .test(0);
+
+        int c = counter[0];
+        assertTrue("" + c, c > 0);
+        assertTrue("" + c, c < 10000);
+    }
 }

From 0901ffb30d41f045b995f1f3453219b142f20e90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Brais=20Gab=C3=ADn?= <braisgabin@gmail.com>
Date: Thu, 2 Feb 2017 19:45:07 +0100
Subject: [PATCH 215/263] Improve the BehaviorSubject Java doc (#5048)

1.x: Improve the BehaviorSubject Java doc
---
 src/main/java/rx/subjects/BehaviorSubject.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/subjects/BehaviorSubject.java b/src/main/java/rx/subjects/BehaviorSubject.java
index 551f7f6c23..8a45cf1df9 100644
--- a/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/src/main/java/rx/subjects/BehaviorSubject.java
@@ -35,14 +35,14 @@
  * <p>
  * <pre> {@code
 
-  // observer will receive all events.
+  // observer will receive all 4 events (including "default").
   BehaviorSubject<Object> subject = BehaviorSubject.create("default");
   subject.subscribe(observer);
   subject.onNext("one");
   subject.onNext("two");
   subject.onNext("three");
 
-  // observer will receive the "one", "two" and "three" events, but not "zero"
+  // observer will receive the "one", "two" and "three" events, but not "default" and "zero"
   BehaviorSubject<Object> subject = BehaviorSubject.create("default");
   subject.onNext("zero");
   subject.onNext("one");

From a37e292cfeb6c46559c397d730966d402b106fe5 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 3 Feb 2017 09:18:13 +0100
Subject: [PATCH 216/263] Release 1.2.6

---
 CHANGES.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 9ec1cae969..c20f538c36 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,17 @@
 # RxJava Releases #
 
+### Version 1.2.6 - February 3, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.6%7C))
+
+#### Documentation
+
+- [Pull 5000](https://github.com/ReactiveX/RxJava/pull/5000): Add which are the other stardard methods of create
+- [Pull 5007](https://github.com/ReactiveX/RxJava/pull/5007): update `sample(time)` diagram to indicate emission of last
+- [Pull 5048](https://github.com/ReactiveX/RxJava/pull/5048): Improve the javadoc of `BehaviorSubject`
+
+#### Bugfixes
+
+- [Pull 5030](https://github.com/ReactiveX/RxJava/pull/5030): fix `groupBy` consuming the upstream in an unbounded manner
+
 ### Version 1.2.5 - January 6, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.5%7C))
 
 #### Documentation

From 47e6c676c5a642c14053eafb03d861a9bf8c87be Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 10 Feb 2017 09:38:13 +0100
Subject: [PATCH 217/263] 1.x: deprecate create(), add alternatives (#5086)

---
 src/main/java/rx/Completable.java             |   2 +-
 src/main/java/rx/Observable.java              | 212 ++++++++++++------
 src/main/java/rx/Single.java                  |   2 +-
 .../operators/EmptyObservableHolder.java      |   2 +-
 .../operators/NeverObservableHolder.java      |   2 +-
 ...romEmitter.java => OnSubscribeCreate.java} |   6 +-
 .../operators/OnSubscribeFlattenIterable.java |   4 +-
 .../operators/OnSubscribeGroupJoin.java       |   2 +-
 .../internal/operators/OnSubscribeRedo.java   |  12 +-
 .../internal/operators/OperatorPublish.java   |   4 +-
 .../rx/internal/operators/OperatorReplay.java |   2 +-
 .../util/ScalarSynchronousObservable.java     |   4 +-
 .../java/rx/observables/AsyncOnSubscribe.java |   2 +-
 .../rx/observables/ConnectableObservable.java |   4 +-
 .../java/rx/observables/SyncOnSubscribe.java  |   2 +-
 .../RxJavaObservableExecutionHook.java        |   2 +-
 src/perf/java/rx/OneItemPerf.java             |   2 +-
 .../rx/jmh/InputWithIncrementingInteger.java  |   2 +-
 .../java/rx/operators/FromComparison.java     |   4 +-
 .../java/rx/operators/OperatorRangePerf.java  |   4 +-
 .../rx/operators/OperatorSerializePerf.java   |   6 +-
 .../rx/operators/OperatorTakeLastOnePerf.java |   2 +-
 src/test/java/rx/BackpressureTests.java       |   4 +-
 src/test/java/rx/CompletableTest.java         |   2 +-
 src/test/java/rx/ConcatTests.java             |   2 +-
 src/test/java/rx/EventStream.java             |   2 +-
 src/test/java/rx/MergeTests.java              |   2 +-
 src/test/java/rx/ObservableTests.java         |  26 +--
 src/test/java/rx/SubscriberTest.java          |   8 +-
 .../java/rx/exceptions/ExceptionsTest.java    |   8 +-
 .../operators/BlockingOperatorNextTest.java   |   2 +-
 .../BlockingOperatorToFutureTest.java         |   6 +-
 .../BlockingOperatorToIteratorTest.java       |   4 +-
 .../operators/CachedObservableTest.java       |   4 +-
 .../operators/OnSubscribeAmbTest.java         |  12 +-
 .../operators/OnSubscribeCollectTest.java     |   6 +-
 ...erTest.java => OnSubscribeCreateTest.java} |  88 ++++----
 .../operators/OnSubscribeDetachTest.java      |   2 +-
 .../operators/OnSubscribeDoOnEachTest.java    |   8 +-
 .../operators/OnSubscribeFromArrayTest.java   |   2 +-
 .../OnSubscribeFromIterableTest.java          |   6 +-
 .../operators/OnSubscribeMapTest.java         |   2 +-
 .../operators/OnSubscribeReduceTest.java      |   6 +-
 .../operators/OnSubscribeRefCountTest.java    |   4 +-
 .../operators/OnSubscribeToMapTest.java       |   6 +-
 .../operators/OnSubscribeToMultimapTest.java  |   6 +-
 .../operators/OnSubscribeUsingTest.java       |   2 +-
 .../internal/operators/OperatorAllTest.java   |   6 +-
 .../internal/operators/OperatorAnyTest.java   |   6 +-
 .../operators/OperatorBufferTest.java         |  36 +--
 .../operators/OperatorConcatTest.java         |  36 +--
 .../operators/OperatorDebounceTest.java       |   6 +-
 .../operators/OperatorDoOnRequestTest.java    |   2 +-
 .../operators/OperatorDoOnSubscribeTest.java  |   2 +-
 .../operators/OperatorGroupByTest.java        |  18 +-
 .../operators/OperatorMaterializeTest.java    |   6 +-
 .../OperatorMergeDelayErrorTest.java          |  66 +++---
 .../OperatorMergeMaxConcurrentTest.java       |   2 +-
 .../internal/operators/OperatorMergeTest.java |  44 ++--
 .../operators/OperatorObserveOnTest.java      |   2 +-
 .../OperatorOnBackpressureBufferTest.java     |   2 +-
 .../OperatorOnBackpressureDropTest.java       |  12 +-
 ...ratorOnErrorResumeNextViaFunctionTest.java |   6 +-
 ...torOnErrorResumeNextViaObservableTest.java |   8 +-
 .../operators/OperatorOnErrorReturnTest.java  |   4 +-
 ...nExceptionResumeNextViaObservableTest.java |  10 +-
 .../operators/OperatorPublishTest.java        |   4 +-
 .../operators/OperatorRepeatTest.java         |   4 +-
 .../operators/OperatorReplayTest.java         |   4 +-
 .../internal/operators/OperatorRetryTest.java |  40 ++--
 .../OperatorRetryWithPredicateTest.java       |  12 +-
 .../operators/OperatorSampleTest.java         |  12 +-
 .../internal/operators/OperatorScanTest.java  |   4 +-
 .../operators/OperatorSerializeTest.java      |   8 +-
 .../operators/OperatorSubscribeOnTest.java    |   8 +-
 .../operators/OperatorSwitchIfEmptyTest.java  |   8 +-
 .../operators/OperatorSwitchTest.java         |  54 ++---
 .../internal/operators/OperatorTakeTest.java  |  14 +-
 .../operators/OperatorTakeUntilTest.java      |  10 +-
 .../operators/OperatorTakeWhileTest.java      |   6 +-
 .../operators/OperatorThrottleFirstTest.java  |   4 +-
 .../operators/OperatorTimeoutTests.java       |   8 +-
 .../OperatorTimeoutWithSelectorTest.java      |   2 +-
 .../operators/OperatorUnsubscribeOnTest.java  |   4 +-
 .../operators/OperatorWindowWithSizeTest.java |   2 +-
 ...ratorWindowWithStartEndObservableTest.java |  10 +-
 .../operators/OperatorWindowWithTimeTest.java |   4 +-
 .../internal/operators/OperatorZipTest.java   |   8 +-
 .../operators/SafeSubscriberTest.java         |   8 +-
 .../rx/internal/producers/ProducersTest.java  |   2 +-
 .../rx/observables/AsyncOnSubscribeTest.java  |  28 +--
 .../observables/BlockingObservableTest.java   |   6 +-
 .../rx/observables/SyncOnSubscribeTest.java   |  46 ++--
 .../rx/observers/SerializedObserverTest.java  |  10 +-
 .../AbstractSchedulerConcurrencyTests.java    |   2 +-
 .../rx/schedulers/AbstractSchedulerTests.java |   6 +-
 .../java/rx/schedulers/TestSchedulerTest.java |   2 +-
 .../ReplaySubjectBoundedConcurrencyTest.java  |   2 +-
 .../ReplaySubjectConcurrencyTest.java         |   4 +-
 99 files changed, 595 insertions(+), 529 deletions(-)
 rename src/main/java/rx/internal/operators/{OnSubscribeFromEmitter.java => OnSubscribeCreate.java} (97%)
 rename src/test/java/rx/internal/operators/{OnSubscribeFromEmitterTest.java => OnSubscribeCreateTest.java} (80%)

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index e9b78c569f..536509b39a 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -2249,7 +2249,7 @@ public final <R> R to(Func1<? super Completable, R> converter) {
      * @return the new Observable created
      */
     public final <T> Observable<T> toObservable() {
-        return Observable.create(new Observable.OnSubscribe<T>() {
+        return Observable.unsafeCreate(new Observable.OnSubscribe<T>() {
             @Override
             public void call(Subscriber<? super T> s) {
                 unsafeSubscribe(s);
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 67e4d6149e..89e1aea07c 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -51,7 +51,7 @@ public class Observable<T> {
     /**
      * Creates an Observable with a Function to execute when it is subscribed to.
      * <p>
-     * <em>Note:</em> Use {@link #create(OnSubscribe)} to create an Observable, instead of this constructor,
+     * <em>Note:</em> Use {@link #unsafeCreate(OnSubscribe)} to create an Observable, instead of this constructor,
      * unless you specifically have a need for inheritance.
      *
      * @param f
@@ -62,10 +62,72 @@ protected Observable(OnSubscribe<T> f) {
     }
 
     /**
-     * <strong>This method requires advanced knowledge about building operators and data sources; please consider
-     * other standard methods first, such as {@link Observable#fromEmitter(Action1, Emitter.BackpressureMode)};</strong>
-     * Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to
-     * it.
+     * Constructs an Observable in an unsafe manner, that is, unsubscription and backpressure handling
+     * is the responsibility of the OnSubscribe implementation.
+     * @param <T> the value type emitted
+     * @param f the callback to execute for each individual Subscriber that subscribes to the
+     *          returned Observable
+     * @return the new Observable instance
+     * @deprecated 1.2.7 - inherently unsafe, use the other create() methods for basic cases or
+     * see {@link #unsafeCreate(OnSubscribe)} for advanced cases (such as custom operators)
+     * @see #create(SyncOnSubscribe)
+     * @see #create(AsyncOnSubscribe)
+     * @see #create(Action1, rx.Emitter.BackpressureMode)
+     */
+    @Deprecated
+    public static <T> Observable<T> create(OnSubscribe<T> f) {
+        return new Observable<T>(RxJavaHooks.onCreate(f));
+    }
+
+    /**
+     * Provides an API (via a cold Observable) that bridges the reactive world with the callback-style,
+     * generally non-backpressured world.
+     * <p>
+     * Example:
+     * <pre><code>
+     * Observable.&lt;Event&gt;create(emitter -&gt; {
+     *     Callback listener = new Callback() {
+     *         &#64;Override
+     *         public void onEvent(Event e) {
+     *             emitter.onNext(e);
+     *             if (e.isLast()) {
+     *                 emitter.onCompleted();
+     *             }
+     *         }
+     *
+     *         &#64;Override
+     *         public void onFailure(Exception e) {
+     *             emitter.onError(e);
+     *         }
+     *     };
+     *
+     *     AutoCloseable c = api.someMethod(listener);
+     *
+     *     emitter.setCancellation(c::close);
+     *
+     * }, BackpressureMode.BUFFER);
+     * </code></pre>
+     * <p>
+     * You should call the Emitter's onNext, onError and onCompleted methods in a serialized fashion. The
+     * rest of its methods are thread-safe.
+     *
+     * @param <T> the element type
+     * @param emitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
+     * @param backpressure the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
+     * @return the new Observable instance
+     * @see Emitter
+     * @see Emitter.BackpressureMode
+     * @see rx.functions.Cancellable
+     * @since 1.2.7 - experimental
+     */
+    @Experimental
+    public static <T> Observable<T> create(Action1<Emitter<T>> emitter, Emitter.BackpressureMode backpressure) {
+        return unsafeCreate(new OnSubscribeCreate<T>(emitter, backpressure));
+    }
+
+    /**
+     * Returns an Observable that executes the given OnSubscribe action for each individual Subscriber
+     * that subscribes; <strong>unsubscription and backpressure must be implemented manually.</strong>
      * <p>
      * <img width="640" height="200" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/create.png" alt="">
      * <p>
@@ -84,7 +146,7 @@ protected Observable(OnSubscribe<T> f) {
      *  document the fact that the consumer of the returned {@code Observable} has to apply one of
      *  the {@code onBackpressureXXX} operators.</dd>
      *  <dt><b>Scheduler:</b></dt>
-     *  <dd>{@code create} does not operate by default on a particular {@link Scheduler}.</dd>
+     *  <dd>{@code unsafeCreate} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
      * @param <T>
@@ -95,8 +157,10 @@ protected Observable(OnSubscribe<T> f) {
      * @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the specified
      *         function
      * @see <a href="http://reactivex.io/documentation/operators/create.html">ReactiveX operators documentation: Create</a>
+     * @since 1.2.7 - experimental
      */
-    public static <T> Observable<T> create(OnSubscribe<T> f) {
+    @Experimental
+    public static <T> Observable<T> unsafeCreate(OnSubscribe<T> f) {
         return new Observable<T>(RxJavaHooks.onCreate(f));
     }
 
@@ -140,7 +204,7 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
      * @since 1.2
      */
     public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe) {
-        return create((OnSubscribe<T>)syncOnSubscribe);
+        return unsafeCreate(syncOnSubscribe);
     }
 
     /**
@@ -183,7 +247,7 @@ public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe)
      */
     @Experimental
     public static <S, T> Observable<T> create(AsyncOnSubscribe<S, T> asyncOnSubscribe) {
-        return create((OnSubscribe<T>)asyncOnSubscribe);
+        return unsafeCreate(asyncOnSubscribe);
     }
 
     /**
@@ -234,7 +298,7 @@ public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<
      * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Implementing-Your-Own-Operators">RxJava wiki: Implementing Your Own Operators</a>
      */
     public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
-        return create(new OnSubscribeLift<T, R>(onSubscribe, operator));
+        return unsafeCreate(new OnSubscribeLift<T, R>(onSubscribe, operator));
     }
 
     /**
@@ -373,7 +437,7 @@ public Completable toCompletable() {
      * @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>
      */
     public static <T> Observable<T> amb(Iterable<? extends Observable<? extends T>> sources) {
-        return create(OnSubscribeAmb.amb(sources));
+        return unsafeCreate(OnSubscribeAmb.amb(sources));
     }
 
     /**
@@ -399,7 +463,7 @@ public static <T> Observable<T> amb(Iterable<? extends Observable<? extends T>>
      * @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>
      */
     public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2) {
-        return create(OnSubscribeAmb.amb(o1, o2));
+        return unsafeCreate(OnSubscribeAmb.amb(o1, o2));
     }
 
     /**
@@ -427,7 +491,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>
      */
     public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3) {
-        return create(OnSubscribeAmb.amb(o1, o2, o3));
+        return unsafeCreate(OnSubscribeAmb.amb(o1, o2, o3));
     }
 
     /**
@@ -457,7 +521,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>
      */
     public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4) {
-        return create(OnSubscribeAmb.amb(o1, o2, o3, o4));
+        return unsafeCreate(OnSubscribeAmb.amb(o1, o2, o3, o4));
     }
 
     /**
@@ -489,7 +553,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>
      */
     public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5) {
-        return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5));
+        return unsafeCreate(OnSubscribeAmb.amb(o1, o2, o3, o4, o5));
     }
 
     /**
@@ -523,7 +587,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>
      */
     public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6) {
-        return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6));
+        return unsafeCreate(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6));
     }
 
     /**
@@ -559,7 +623,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>
      */
     public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7) {
-        return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6, o7));
+        return unsafeCreate(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6, o7));
     }
 
     /**
@@ -597,7 +661,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>
      */
     public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8) {
-        return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8));
+        return unsafeCreate(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8));
     }
 
     /**
@@ -637,7 +701,7 @@ public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? ext
      * @see <a href="http://reactivex.io/documentation/operators/amb.html">ReactiveX operators documentation: Amb</a>
      */
     public static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8, Observable<? extends T> o9) {
-        return create(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8, o9));
+        return unsafeCreate(OnSubscribeAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8, o9));
     }
 
     /**
@@ -1020,7 +1084,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combineLates
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
     public static <T, R> Observable<R> combineLatest(List<? extends Observable<? extends T>> sources, FuncN<? extends R> combineFunction) {
-        return create(new OnSubscribeCombineLatest<T, R>(sources, combineFunction));
+        return unsafeCreate(new OnSubscribeCombineLatest<T, R>(sources, combineFunction));
     }
 
     /**
@@ -1049,7 +1113,7 @@ public static <T, R> Observable<R> combineLatest(List<? extends Observable<? ext
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
     public static <T, R> Observable<R> combineLatest(Iterable<? extends Observable<? extends T>> sources, FuncN<? extends R> combineFunction) {
-        return create(new OnSubscribeCombineLatest<T, R>(sources, combineFunction));
+        return unsafeCreate(new OnSubscribeCombineLatest<T, R>(sources, combineFunction));
     }
 
     /**
@@ -1080,7 +1144,7 @@ public static <T, R> Observable<R> combineLatest(Iterable<? extends Observable<?
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
     public static <T, R> Observable<R> combineLatestDelayError(Iterable<? extends Observable<? extends T>> sources, FuncN<? extends R> combineFunction) {
-        return create(new OnSubscribeCombineLatest<T, R>(null, sources, combineFunction, RxRingBuffer.SIZE, true));
+        return unsafeCreate(new OnSubscribeCombineLatest<T, R>(null, sources, combineFunction, RxRingBuffer.SIZE, true));
     }
 
     /**
@@ -1762,7 +1826,7 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @see <a href="http://reactivex.io/documentation/operators/defer.html">ReactiveX operators documentation: Defer</a>
      */
     public static <T> Observable<T> defer(Func0<Observable<T>> observableFactory) {
-        return create(new OnSubscribeDefer<T>(observableFactory));
+        return unsafeCreate(new OnSubscribeDefer<T>(observableFactory));
     }
 
     /**
@@ -1808,7 +1872,7 @@ public static <T> Observable<T> empty() {
      * @see <a href="http://reactivex.io/documentation/operators/empty-never-throw.html">ReactiveX operators documentation: Throw</a>
      */
     public static <T> Observable<T> error(Throwable exception) {
-        return create(new OnSubscribeThrow<T>(exception));
+        return unsafeCreate(new OnSubscribeThrow<T>(exception));
     }
 
     /**
@@ -1838,7 +1902,7 @@ public static <T> Observable<T> error(Throwable exception) {
      */
     @SuppressWarnings("cast")
     public static <T> Observable<T> from(Future<? extends T> future) {
-        return (Observable<T>)create(OnSubscribeToObservableFuture.toObservableFuture(future));
+        return (Observable<T>)unsafeCreate(OnSubscribeToObservableFuture.toObservableFuture(future));
     }
 
     /**
@@ -1872,7 +1936,7 @@ public static <T> Observable<T> from(Future<? extends T> future) {
      */
     @SuppressWarnings("cast")
     public static <T> Observable<T> from(Future<? extends T> future, long timeout, TimeUnit unit) {
-        return (Observable<T>)create(OnSubscribeToObservableFuture.toObservableFuture(future, timeout, unit));
+        return (Observable<T>)unsafeCreate(OnSubscribeToObservableFuture.toObservableFuture(future, timeout, unit));
     }
 
     /**
@@ -1904,7 +1968,7 @@ public static <T> Observable<T> from(Future<? extends T> future, long timeout, T
     public static <T> Observable<T> from(Future<? extends T> future, Scheduler scheduler) {
         // TODO in a future revision the Scheduler will become important because we'll start polling instead of blocking on the Future
         @SuppressWarnings("cast")
-        Observable<T> o = (Observable<T>)create(OnSubscribeToObservableFuture.toObservableFuture(future));
+        Observable<T> o = (Observable<T>)unsafeCreate(OnSubscribeToObservableFuture.toObservableFuture(future));
         return o.subscribeOn(scheduler);
     }
 
@@ -1929,7 +1993,7 @@ public static <T> Observable<T> from(Future<? extends T> future, Scheduler sched
      * @see <a href="http://reactivex.io/documentation/operators/from.html">ReactiveX operators documentation: From</a>
      */
     public static <T> Observable<T> from(Iterable<? extends T> iterable) {
-        return create(new OnSubscribeFromIterable<T>(iterable));
+        return unsafeCreate(new OnSubscribeFromIterable<T>(iterable));
     }
 
     /**
@@ -1959,7 +2023,7 @@ public static <T> Observable<T> from(T[] array) {
         if (n == 1) {
             return just(array[0]);
         }
-        return create(new OnSubscribeFromArray<T>(array));
+        return unsafeCreate(new OnSubscribeFromArray<T>(array));
     }
 
     /**
@@ -2002,10 +2066,12 @@ public static <T> Observable<T> from(T[] array) {
      * @see Emitter.BackpressureMode
      * @see rx.functions.Cancellable
      * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @deprecated 1.2.7 - aliased to {@link #create(Action1, rx.Emitter.BackpressureMode)}, will be removed in 1.3.0
      */
     @Experimental
+    @Deprecated
     public static <T> Observable<T> fromEmitter(Action1<Emitter<T>> emitter, Emitter.BackpressureMode backpressure) {
-        return create(new OnSubscribeFromEmitter<T>(emitter, backpressure));
+        return unsafeCreate(new OnSubscribeCreate<T>(emitter, backpressure));
     }
 
     /**
@@ -2033,7 +2099,7 @@ public static <T> Observable<T> fromEmitter(Action1<Emitter<T>> emitter, Emitter
      * @since 1.2
      */
     public static <T> Observable<T> fromCallable(Callable<? extends T> func) {
-        return create(new OnSubscribeFromCallable<T>(func));
+        return unsafeCreate(new OnSubscribeFromCallable<T>(func));
     }
 
     /**
@@ -2140,7 +2206,7 @@ public static Observable<Long> interval(long initialDelay, long period, TimeUnit
      * @since 1.0.12
      */
     public static Observable<Long> interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
-        return create(new OnSubscribeTimerPeriodically(initialDelay, period, unit, scheduler));
+        return unsafeCreate(new OnSubscribeTimerPeriodically(initialDelay, period, unit, scheduler));
     }
 
     /**
@@ -3473,7 +3539,7 @@ public static Observable<Integer> range(int start, int count) {
         if (count == 1) {
             return Observable.just(start);
         }
-        return Observable.create(new OnSubscribeRange(start, start + (count - 1)));
+        return Observable.unsafeCreate(new OnSubscribeRange(start, start + (count - 1)));
     }
 
     /**
@@ -3733,7 +3799,7 @@ public static Observable<Long> timer(long delay, TimeUnit unit) {
      * @see <a href="http://reactivex.io/documentation/operators/timer.html">ReactiveX operators documentation: Timer</a>
      */
     public static Observable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler) {
-        return create(new OnSubscribeTimerOnce(delay, unit, scheduler));
+        return unsafeCreate(new OnSubscribeTimerOnce(delay, unit, scheduler));
     }
 
     /**
@@ -3803,7 +3869,7 @@ public static <T, Resource> Observable<T> using(
             final Func0<Resource> resourceFactory,
             final Func1<? super Resource, ? extends Observable<? extends T>> observableFactory,
             final Action1<? super Resource> disposeAction, boolean disposeEagerly) {
-        return create(new OnSubscribeUsing<T, Resource>(resourceFactory, observableFactory, disposeAction, disposeEagerly));
+        return unsafeCreate(new OnSubscribeUsing<T, Resource>(resourceFactory, observableFactory, disposeAction, disposeEagerly));
     }
 
     /**
@@ -5070,7 +5136,7 @@ public final <R> Observable<R> collect(Func0<R> stateFactory, final Action2<R, ?
          *
          * It should use last() not takeLast(1) since it needs to emit an error if the sequence is empty.
          */
-        return create(new OnSubscribeCollect<T, R>(this, stateFactory, collector));
+        return unsafeCreate(new OnSubscribeCollect<T, R>(this, stateFactory, collector));
     }
 
     /**
@@ -5103,7 +5169,7 @@ public final <R> Observable<R> concatMap(Func1<? super T, ? extends Observable<?
             ScalarSynchronousObservable<T> scalar = (ScalarSynchronousObservable<T>) this;
             return scalar.scalarFlatMap(func);
         }
-        return create(new OnSubscribeConcatMap<T, R>(this, func, 2, OnSubscribeConcatMap.IMMEDIATE));
+        return unsafeCreate(new OnSubscribeConcatMap<T, R>(this, func, 2, OnSubscribeConcatMap.IMMEDIATE));
     }
 
     /**
@@ -5134,7 +5200,7 @@ public final <R> Observable<R> concatMapDelayError(Func1<? super T, ? extends Ob
             ScalarSynchronousObservable<T> scalar = (ScalarSynchronousObservable<T>) this;
             return scalar.scalarFlatMap(func);
         }
-        return create(new OnSubscribeConcatMap<T, R>(this, func, 2, OnSubscribeConcatMap.END));
+        return unsafeCreate(new OnSubscribeConcatMap<T, R>(this, func, 2, OnSubscribeConcatMap.END));
     }
 
     /**
@@ -5580,7 +5646,7 @@ public final Observable<T> delaySubscription(long delay, TimeUnit unit) {
      * @see <a href="http://reactivex.io/documentation/operators/delay.html">ReactiveX operators documentation: Delay</a>
      */
     public final Observable<T> delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) {
-        return create(new OnSubscribeDelaySubscription<T>(this, delay, unit, scheduler));
+        return unsafeCreate(new OnSubscribeDelaySubscription<T>(this, delay, unit, scheduler));
     }
 
     /**
@@ -5606,7 +5672,7 @@ public final Observable<T> delaySubscription(long delay, TimeUnit unit, Schedule
      * @see <a href="http://reactivex.io/documentation/operators/delay.html">ReactiveX operators documentation: Delay</a>
      */
     public final <U> Observable<T> delaySubscription(Func0<? extends Observable<U>> subscriptionDelay) {
-        return create(new OnSubscribeDelaySubscriptionWithSelector<T, U>(this, subscriptionDelay));
+        return unsafeCreate(new OnSubscribeDelaySubscriptionWithSelector<T, U>(this, subscriptionDelay));
     }
 
     /**
@@ -5633,7 +5699,7 @@ public final <U> Observable<T> delaySubscription(Observable<U> other) {
         if (other == null) {
             throw new NullPointerException();
         }
-        return create(new OnSubscribeDelaySubscriptionOther<T, U>(this, other));
+        return unsafeCreate(new OnSubscribeDelaySubscriptionOther<T, U>(this, other));
     }
 
     /**
@@ -5800,7 +5866,7 @@ public final Observable<T> doOnCompleted(final Action0 onCompleted) {
         Action1<Throwable> onError = Actions.empty();
         Observer<T> observer = new ActionObserver<T>(onNext, onError, onCompleted);
 
-        return create(new OnSubscribeDoOnEach<T>(this, observer));
+        return unsafeCreate(new OnSubscribeDoOnEach<T>(this, observer));
     }
 
     /**
@@ -5822,7 +5888,7 @@ public final Observable<T> doOnCompleted(final Action0 onCompleted) {
      */
     public final Observable<T> doOnEach(final Action1<Notification<? super T>> onNotification) {
         Observer<T> observer = new ActionNotificationObserver<T>(onNotification);
-        return create(new OnSubscribeDoOnEach<T>(this, observer));
+        return unsafeCreate(new OnSubscribeDoOnEach<T>(this, observer));
     }
 
     /**
@@ -5849,7 +5915,7 @@ public final Observable<T> doOnEach(final Action1<Notification<? super T>> onNot
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
      */
     public final Observable<T> doOnEach(Observer<? super T> observer) {
-        return create(new OnSubscribeDoOnEach<T>(this, observer));
+        return unsafeCreate(new OnSubscribeDoOnEach<T>(this, observer));
     }
 
     /**
@@ -5877,7 +5943,7 @@ public final Observable<T> doOnError(final Action1<? super Throwable> onError) {
         Action0 onCompleted = Actions.empty();
         Observer<T> observer = new ActionObserver<T>(onNext, onError, onCompleted);
 
-        return create(new OnSubscribeDoOnEach<T>(this, observer));
+        return unsafeCreate(new OnSubscribeDoOnEach<T>(this, observer));
     }
 
     /**
@@ -5902,7 +5968,7 @@ public final Observable<T> doOnNext(final Action1<? super T> onNext) {
         Action0 onCompleted = Actions.empty();
         Observer<T> observer = new ActionObserver<T>(onNext, onError, onCompleted);
 
-        return create(new OnSubscribeDoOnEach<T>(this, observer));
+        return unsafeCreate(new OnSubscribeDoOnEach<T>(this, observer));
     }
 
     /**
@@ -5983,7 +6049,7 @@ public final Observable<T> doOnTerminate(final Action0 onTerminate) {
 
         Observer<T> observer = new ActionObserver<T>(onNext, onError, onTerminate);
 
-        return create(new OnSubscribeDoOnEach<T>(this, observer));
+        return unsafeCreate(new OnSubscribeDoOnEach<T>(this, observer));
     }
 
     /**
@@ -6559,7 +6625,7 @@ public final Observable<Boolean> exists(Func1<? super T, Boolean> predicate) {
      * @see <a href="http://reactivex.io/documentation/operators/filter.html">ReactiveX operators documentation: Filter</a>
      */
     public final Observable<T> filter(Func1<? super T, Boolean> predicate) {
-        return create(new OnSubscribeFilter<T>(this, predicate));
+        return unsafeCreate(new OnSubscribeFilter<T>(this, predicate));
     }
 
     /**
@@ -7301,7 +7367,7 @@ public final <K> Observable<GroupedObservable<K, T>> groupBy(final Func1<? super
     public final <T2, D1, D2, R> Observable<R> groupJoin(Observable<T2> right, Func1<? super T, ? extends Observable<D1>> leftDuration,
             Func1<? super T2, ? extends Observable<D2>> rightDuration,
             Func2<? super T, ? super Observable<T2>, ? extends R> resultSelector) {
-        return create(new OnSubscribeGroupJoin<T, T2, D1, D2, R>(this, right, leftDuration, rightDuration, resultSelector));
+        return unsafeCreate(new OnSubscribeGroupJoin<T, T2, D1, D2, R>(this, right, leftDuration, rightDuration, resultSelector));
     }
 
     /**
@@ -7383,7 +7449,7 @@ public final Observable<Boolean> isEmpty() {
     public final <TRight, TLeftDuration, TRightDuration, R> Observable<R> join(Observable<TRight> right, Func1<T, Observable<TLeftDuration>> leftDurationSelector,
             Func1<TRight, Observable<TRightDuration>> rightDurationSelector,
             Func2<T, TRight, R> resultSelector) {
-        return create(new OnSubscribeJoin<T, TRight, TLeftDuration, TRightDuration, R>(this, right, leftDurationSelector, rightDurationSelector, resultSelector));
+        return unsafeCreate(new OnSubscribeJoin<T, TRight, TLeftDuration, TRightDuration, R>(this, right, leftDurationSelector, rightDurationSelector, resultSelector));
     }
 
     /**
@@ -7531,7 +7597,7 @@ public final Observable<T> limit(int count) {
      * @see <a href="http://reactivex.io/documentation/operators/map.html">ReactiveX operators documentation: Map</a>
      */
     public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
-        return create(new OnSubscribeMap<T, R>(this, func));
+        return unsafeCreate(new OnSubscribeMap<T, R>(this, func));
     }
 
     private <R> Observable<R> mapNotification(Func1<? super T, ? extends R> onNext, Func1<? super Throwable, ? extends R> onError, Func0<? extends R> onCompleted) {
@@ -8108,7 +8174,7 @@ public final Observable<T> onExceptionResumeNext(final Observable<? extends T> r
      */
     @Experimental
     public final Observable<T> onTerminateDetach() {
-        return create(new OnSubscribeDetach<T>(this));
+        return unsafeCreate(new OnSubscribeDetach<T>(this));
     }
 
     /**
@@ -8225,7 +8291,7 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
          *
          * It should use last() not takeLast(1) since it needs to emit an error if the sequence is empty.
          */
-        return create(new OnSubscribeReduce<T>(this, accumulator));
+        return unsafeCreate(new OnSubscribeReduce<T>(this, accumulator));
     }
 
     /**
@@ -8273,7 +8339,7 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
      * @see <a href="http://en.wikipedia.org/wiki/Fold_(higher-order_function)">Wikipedia: Fold (higher-order function)</a>
      */
     public final <R> Observable<R> reduce(R initialValue, Func2<R, ? super T, R> accumulator) {
-        return create(new OnSubscribeReduceSeed<T, R>(this, initialValue, accumulator));
+        return unsafeCreate(new OnSubscribeReduceSeed<T, R>(this, initialValue, accumulator));
     }
 
     /**
@@ -9486,7 +9552,7 @@ public final Observable<T> skip(long time, TimeUnit unit) {
      * @see <a href="http://reactivex.io/documentation/operators/skip.html">ReactiveX operators documentation: Skip</a>
      */
     public final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler) {
-        return create(new OnSubscribeSkipTimed<T>(this, time, unit, scheduler));
+        return unsafeCreate(new OnSubscribeSkipTimed<T>(this, time, unit, scheduler));
     }
 
     /**
@@ -10288,7 +10354,7 @@ public final Observable<T> subscribeOn(Scheduler scheduler) {
         if (this instanceof ScalarSynchronousObservable) {
             return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
         }
-        return create(new OperatorSubscribeOn<T>(this, scheduler));
+        return unsafeCreate(new OperatorSubscribeOn<T>(this, scheduler));
     }
 
     /**
@@ -10483,7 +10549,7 @@ public final Observable<T> takeLast(final int count) {
         if (count == 0) {
             return ignoreElements();
         } else if (count == 1) {
-            return create(new OnSubscribeTakeLastOne<T>(this));
+            return unsafeCreate(new OnSubscribeTakeLastOne<T>(this));
         } else {
             return lift(new OperatorTakeLast<T>(count));
         }
@@ -11441,7 +11507,7 @@ public final Observable<List<T>> toList() {
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySelector) {
-        return create(new OnSubscribeToMap<T, K, T>(this, keySelector, UtilityFunctions.<T>identity()));
+        return unsafeCreate(new OnSubscribeToMap<T, K, T>(this, keySelector, UtilityFunctions.<T>identity()));
     }
 
     /**
@@ -11471,7 +11537,7 @@ public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySe
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
-        return create(new OnSubscribeToMap<T, K, V>(this, keySelector, valueSelector));
+        return unsafeCreate(new OnSubscribeToMap<T, K, V>(this, keySelector, valueSelector));
     }
 
     /**
@@ -11500,7 +11566,7 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, V>> mapFactory) {
-        return create(new OnSubscribeToMap<T, K, V>(this, keySelector, valueSelector, mapFactory));
+        return unsafeCreate(new OnSubscribeToMap<T, K, V>(this, keySelector, valueSelector, mapFactory));
     }
 
     /**
@@ -11523,7 +11589,7 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ? extends K> keySelector) {
-        return create(new OnSubscribeToMultimap<T, K, T>(this, keySelector, UtilityFunctions.<T>identity()));
+        return unsafeCreate(new OnSubscribeToMultimap<T, K, T>(this, keySelector, UtilityFunctions.<T>identity()));
     }
 
     /**
@@ -11551,7 +11617,7 @@ public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ?
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
-        return create(new OnSubscribeToMultimap<T, K, V>(this, keySelector, valueSelector));
+        return unsafeCreate(new OnSubscribeToMultimap<T, K, V>(this, keySelector, valueSelector));
     }
 
     /**
@@ -11581,7 +11647,7 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, Collection<V>>> mapFactory) {
-        return create(new OnSubscribeToMultimap<T, K, V>(this, keySelector, valueSelector, mapFactory));
+        return unsafeCreate(new OnSubscribeToMultimap<T, K, V>(this, keySelector, valueSelector, mapFactory));
     }
 
     /**
@@ -11613,7 +11679,7 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
      */
     public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, Collection<V>>> mapFactory, Func1<? super K, ? extends Collection<V>> collectionFactory) {
-        return create(new OnSubscribeToMultimap<T, K, V>(this, keySelector, valueSelector, mapFactory, collectionFactory));
+        return unsafeCreate(new OnSubscribeToMultimap<T, K, V>(this, keySelector, valueSelector, mapFactory, collectionFactory));
     }
 
     /**
@@ -11857,7 +11923,7 @@ public final <U, R> Observable<R> withLatestFrom(Observable<? extends U> other,
      */
     @Experimental
     public final <T1, T2, R> Observable<R> withLatestFrom(Observable<T1> o1, Observable<T2> o2, Func3<? super T, ? super T1, ? super T2, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this, new Observable<?>[] { o1, o2 }, null, Functions.fromFunc(combiner)));
+        return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this, new Observable<?>[] { o1, o2 }, null, Functions.fromFunc(combiner)));
     }
 
     /**
@@ -11894,7 +11960,7 @@ public final <T1, T2, T3, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3,
             Func4<? super T, ? super T1, ? super T2, ? super T3, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this,
+        return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3 }, null, Functions.fromFunc(combiner)));
     }
 
@@ -11934,7 +12000,7 @@ public final <T1, T2, T3, T4, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3, Observable<T4> o4,
             Func5<? super T, ? super T1, ? super T2, ? super T3, ? super T4, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this,
+        return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3, o4 }, null, Functions.fromFunc(combiner)));
     }
     /**
@@ -11976,7 +12042,7 @@ public final <T1, T2, T3, T4, T5, R> Observable<R> withLatestFrom(
             Observable<T3> o3, Observable<T4> o4,
             Observable<T5> o5,
             Func6<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this,
+        return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3, o4, o5 }, null, Functions.fromFunc(combiner)));
     }
 
@@ -12021,7 +12087,7 @@ public final <T1, T2, T3, T4, T5, T6, R> Observable<R> withLatestFrom(
             Observable<T3> o3, Observable<T4> o4,
             Observable<T5> o5, Observable<T6> o6,
             Func7<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this,
+        return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3, o4, o5, o6 }, null, Functions.fromFunc(combiner)));
     }
 
@@ -12069,7 +12135,7 @@ public final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> withLatestFrom(
             Observable<T5> o5, Observable<T6> o6,
             Observable<T7> o7,
             Func8<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this,
+        return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7 }, null, Functions.fromFunc(combiner)));
     }
 
@@ -12119,7 +12185,7 @@ public final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> withLatestFrom(
             Observable<T5> o5, Observable<T6> o6,
             Observable<T7> o7, Observable<T8> o8,
             Func9<? super T, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this,
+        return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this,
                 new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7, o8 }, null, Functions.fromFunc(combiner)));
     }
 
@@ -12149,7 +12215,7 @@ public final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> withLatestFrom(
      */
     @Experimental
     public final <R> Observable<R> withLatestFrom(Observable<?>[] others, FuncN<R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this, others, null, combiner));
+        return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this, others, null, combiner));
     }
 
     /**
@@ -12178,7 +12244,7 @@ public final <R> Observable<R> withLatestFrom(Observable<?>[] others, FuncN<R> c
      */
     @Experimental
     public final <R> Observable<R> withLatestFrom(Iterable<Observable<?>> others, FuncN<R> combiner) {
-        return create(new OperatorWithLatestFromMany<T, R>(this, null, others, combiner));
+        return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this, null, others, combiner));
     }
 
     /**
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 782d5c833f..709b709f41 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -202,7 +202,7 @@ public interface Transformer<T, R> extends Func1<Single<T>, Single<R>> {
      */
     private static <T> Observable<T> asObservable(Single<T> t) {
         // is this sufficient, or do I need to keep the outer Single and subscribe to it?
-        return Observable.create(new SingleToObservable<T>(t.onSubscribe));
+        return Observable.unsafeCreate(new SingleToObservable<T>(t.onSubscribe));
     }
 
     /* *********************************************************************************************************
diff --git a/src/main/java/rx/internal/operators/EmptyObservableHolder.java b/src/main/java/rx/internal/operators/EmptyObservableHolder.java
index e582407bee..e386539c66 100644
--- a/src/main/java/rx/internal/operators/EmptyObservableHolder.java
+++ b/src/main/java/rx/internal/operators/EmptyObservableHolder.java
@@ -28,7 +28,7 @@ public enum EmptyObservableHolder implements OnSubscribe<Object> {
     ;
 
     /** The singleton instance. */
-    static final Observable<Object> EMPTY = Observable.create(INSTANCE);
+    static final Observable<Object> EMPTY = Observable.unsafeCreate(INSTANCE);
 
 
     /**
diff --git a/src/main/java/rx/internal/operators/NeverObservableHolder.java b/src/main/java/rx/internal/operators/NeverObservableHolder.java
index 6a80d22e8b..056c08b034 100644
--- a/src/main/java/rx/internal/operators/NeverObservableHolder.java
+++ b/src/main/java/rx/internal/operators/NeverObservableHolder.java
@@ -28,7 +28,7 @@ public enum NeverObservableHolder implements OnSubscribe<Object> {
     ;
 
     /** The singleton instance. */
-    static final Observable<Object> NEVER = Observable.create(INSTANCE);
+    static final Observable<Object> NEVER = Observable.unsafeCreate(INSTANCE);
 
     /**
      * Returns a type-corrected singleton instance of the never Observable.
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java b/src/main/java/rx/internal/operators/OnSubscribeCreate.java
similarity index 97%
rename from src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
rename to src/main/java/rx/internal/operators/OnSubscribeCreate.java
index 355ae99c1d..497b240ec0 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFromEmitter.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeCreate.java
@@ -29,13 +29,13 @@
 import rx.plugins.RxJavaHooks;
 import rx.subscriptions.SerialSubscription;
 
-public final class OnSubscribeFromEmitter<T> implements OnSubscribe<T> {
+public final class OnSubscribeCreate<T> implements OnSubscribe<T> {
 
     final Action1<Emitter<T>> Emitter;
 
     final Emitter.BackpressureMode backpressure;
 
-    public OnSubscribeFromEmitter(Action1<Emitter<T>> Emitter, Emitter.BackpressureMode backpressure) {
+    public OnSubscribeCreate(Action1<Emitter<T>> Emitter, Emitter.BackpressureMode backpressure) {
         this.Emitter = Emitter;
         this.backpressure = backpressure;
     }
@@ -268,7 +268,7 @@ public void onError(Throwable e) {
 
         @Override
         void onOverflow() {
-            onError(new MissingBackpressureException("fromEmitter: could not emit value due to lack of requests"));
+            onError(new MissingBackpressureException("create: could not emit value due to lack of requests"));
         }
 
     }
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
index 608e6808b7..fe85e55369 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFlattenIterable.java
@@ -70,9 +70,9 @@ public static <T, R> Observable<R> createFrom(Observable<? extends T> source,
             Func1<? super T, ? extends Iterable<? extends R>> mapper, int prefetch) {
         if (source instanceof ScalarSynchronousObservable) {
             T scalar = ((ScalarSynchronousObservable<? extends T>) source).get();
-            return Observable.create(new OnSubscribeScalarFlattenIterable<T, R>(scalar, mapper));
+            return Observable.unsafeCreate(new OnSubscribeScalarFlattenIterable<T, R>(scalar, mapper));
         }
-        return Observable.create(new OnSubscribeFlattenIterable<T, R>(source, mapper, prefetch));
+        return Observable.unsafeCreate(new OnSubscribeFlattenIterable<T, R>(source, mapper, prefetch));
     }
 
     static final class FlattenIterableSubscriber<T, R> extends Subscriber<T> {
diff --git a/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java b/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
index 4666751842..3c99b68262 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java
@@ -170,7 +170,7 @@ public void onNext(T1 args) {
                         leftMap().put(id, subjSerial);
                     }
 
-                    Observable<T2> window = Observable.create(new WindowObservableFunc<T2>(subj, cancel));
+                    Observable<T2> window = Observable.unsafeCreate(new WindowObservableFunc<T2>(subj, cancel));
 
                     Observable<D1> duration = leftDuration.call(args);
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeRedo.java b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
index fc9fe9e4d2..de4f5e4d15 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRedo.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRedo.java
@@ -31,7 +31,7 @@
  * limitations under the License.
  */
 
-import static rx.Observable.create; // NOPMD
+import static rx.Observable.unsafeCreate; // NOPMD
 
 import java.util.concurrent.atomic.*;
 
@@ -133,11 +133,11 @@ public static <T> Observable<T> retry(Observable<T> source, final long count) {
     }
 
     public static <T> Observable<T> retry(Observable<T> source, Func1<? super Observable<? extends Notification<?>>, ? extends Observable<?>> notificationHandler) {
-        return create(new OnSubscribeRedo<T>(source, notificationHandler, true, false, Schedulers.trampoline()));
+        return unsafeCreate(new OnSubscribeRedo<T>(source, notificationHandler, true, false, Schedulers.trampoline()));
     }
 
     public static <T> Observable<T> retry(Observable<T> source, Func1<? super Observable<? extends Notification<?>>, ? extends Observable<?>> notificationHandler, Scheduler scheduler) {
-        return create(new OnSubscribeRedo<T>(source, notificationHandler, true, false, scheduler));
+        return unsafeCreate(new OnSubscribeRedo<T>(source, notificationHandler, true, false, scheduler));
     }
 
     public static <T> Observable<T> repeat(Observable<T> source) {
@@ -163,15 +163,15 @@ public static <T> Observable<T> repeat(Observable<T> source, final long count, S
     }
 
     public static <T> Observable<T> repeat(Observable<T> source, Func1<? super Observable<? extends Notification<?>>, ? extends Observable<?>> notificationHandler) {
-        return create(new OnSubscribeRedo<T>(source, notificationHandler, false, true, Schedulers.trampoline()));
+        return unsafeCreate(new OnSubscribeRedo<T>(source, notificationHandler, false, true, Schedulers.trampoline()));
     }
 
     public static <T> Observable<T> repeat(Observable<T> source, Func1<? super Observable<? extends Notification<?>>, ? extends Observable<?>> notificationHandler, Scheduler scheduler) {
-        return create(new OnSubscribeRedo<T>(source, notificationHandler, false, true, scheduler));
+        return unsafeCreate(new OnSubscribeRedo<T>(source, notificationHandler, false, true, scheduler));
     }
 
     public static <T> Observable<T> redo(Observable<T> source, Func1<? super Observable<? extends Notification<?>>, ? extends Observable<?>> notificationHandler, Scheduler scheduler) {
-        return create(new OnSubscribeRedo<T>(source, notificationHandler, false, false, scheduler));
+        return unsafeCreate(new OnSubscribeRedo<T>(source, notificationHandler, false, false, scheduler));
     }
 
     private OnSubscribeRedo(Observable<T> source, Func1<? super Observable<? extends Notification<?>>, ? extends Observable<?>> f, boolean stopOnComplete, boolean stopOnError,
diff --git a/src/main/java/rx/internal/operators/OperatorPublish.java b/src/main/java/rx/internal/operators/OperatorPublish.java
index 7d087efcb4..c07d084abe 100644
--- a/src/main/java/rx/internal/operators/OperatorPublish.java
+++ b/src/main/java/rx/internal/operators/OperatorPublish.java
@@ -123,7 +123,7 @@ public static <T, R> Observable<R> create(final Observable<? extends T> source,
 
     public static <T, R> Observable<R> create(final Observable<? extends T> source,
             final Func1<? super Observable<T>, ? extends Observable<R>> selector, final boolean delayError) {
-        return create(new OnSubscribe<R>() {
+        return unsafeCreate(new OnSubscribe<R>() {
             @Override
             public void call(final Subscriber<? super R> child) {
                 final OnSubscribePublishMulticast<T> op = new OnSubscribePublishMulticast<T>(RxRingBuffer.SIZE, delayError);
@@ -155,7 +155,7 @@ public void setProducer(Producer p) {
                 child.add(op);
                 child.add(subscriber);
 
-                selector.call(Observable.create(op)).unsafeSubscribe(subscriber);
+                selector.call(Observable.unsafeCreate(op)).unsafeSubscribe(subscriber);
 
                 source.unsafeSubscribe(op.subscriber());
             }
diff --git a/src/main/java/rx/internal/operators/OperatorReplay.java b/src/main/java/rx/internal/operators/OperatorReplay.java
index 53511f9c80..045eae96af 100644
--- a/src/main/java/rx/internal/operators/OperatorReplay.java
+++ b/src/main/java/rx/internal/operators/OperatorReplay.java
@@ -58,7 +58,7 @@ public Object call() {
     public static <T, U, R> Observable<R> multicastSelector(
             final Func0<? extends ConnectableObservable<U>> connectableFactory,
             final Func1<? super Observable<U>, ? extends Observable<R>> selector) {
-        return Observable.create(new OnSubscribe<R>() {
+        return Observable.unsafeCreate(new OnSubscribe<R>() {
             @Override
             public void call(final Subscriber<? super R> child) {
                 ConnectableObservable<U> co;
diff --git a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
index d14269953c..141030266e 100644
--- a/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
+++ b/src/main/java/rx/internal/util/ScalarSynchronousObservable.java
@@ -122,7 +122,7 @@ public void call() {
             };
         }
 
-        return create(new ScalarAsyncOnSubscribe<T>(t, onSchedule));
+        return unsafeCreate(new ScalarAsyncOnSubscribe<T>(t, onSchedule));
     }
 
     /** The OnSubscribe callback for the Observable constructor. */
@@ -225,7 +225,7 @@ public String toString() {
      * @return the new observable
      */
     public <R> Observable<R> scalarFlatMap(final Func1<? super T, ? extends Observable<? extends R>> func) {
-        return create(new OnSubscribe<R>() {
+        return unsafeCreate(new OnSubscribe<R>() {
             @Override
             public void call(final Subscriber<? super R> child) {
                 Observable<? extends R> o = func.call(t);
diff --git a/src/main/java/rx/observables/AsyncOnSubscribe.java b/src/main/java/rx/observables/AsyncOnSubscribe.java
index 35eb618736..e3acb1627e 100644
--- a/src/main/java/rx/observables/AsyncOnSubscribe.java
+++ b/src/main/java/rx/observables/AsyncOnSubscribe.java
@@ -33,7 +33,7 @@
 /**
  * A utility class to create {@code OnSubscribe<T>} functions that respond correctly to back
  * pressure requests from subscribers. This is an improvement over
- * {@link rx.Observable#create(OnSubscribe) Observable.create(OnSubscribe)} which does not provide
+ * {@link rx.Observable#unsafeCreate(OnSubscribe) Observable.create(OnSubscribe)} which does not provide
  * any means of managing back pressure requests out-of-the-box. This variant of an OnSubscribe
  * function allows for the asynchronous processing of requests.
  *
diff --git a/src/main/java/rx/observables/ConnectableObservable.java b/src/main/java/rx/observables/ConnectableObservable.java
index 09ac04257d..f1fffceb5f 100644
--- a/src/main/java/rx/observables/ConnectableObservable.java
+++ b/src/main/java/rx/observables/ConnectableObservable.java
@@ -76,7 +76,7 @@ public void call(Subscription t1) {
      * @see <a href="http://reactivex.io/documentation/operators/refcount.html">ReactiveX documentation: RefCount</a>
      */
     public Observable<T> refCount() {
-        return create(new OnSubscribeRefCount<T>(this));
+        return unsafeCreate(new OnSubscribeRefCount<T>(this));
     }
 
     /**
@@ -125,6 +125,6 @@ public Observable<T> autoConnect(int numberOfSubscribers, Action1<? super Subscr
             this.connect(connection);
             return this;
         }
-        return create(new OnSubscribeAutoConnect<T>(this, numberOfSubscribers, connection));
+        return unsafeCreate(new OnSubscribeAutoConnect<T>(this, numberOfSubscribers, connection));
     }
 }
diff --git a/src/main/java/rx/observables/SyncOnSubscribe.java b/src/main/java/rx/observables/SyncOnSubscribe.java
index dc9e2a7a3c..cf848e7bc4 100644
--- a/src/main/java/rx/observables/SyncOnSubscribe.java
+++ b/src/main/java/rx/observables/SyncOnSubscribe.java
@@ -29,7 +29,7 @@
 /**
  * A utility class to create {@code OnSubscribe<T>} functions that responds correctly to back
  * pressure requests from subscribers. This is an improvement over
- * {@link rx.Observable#create(OnSubscribe) Observable.create(OnSubscribe)} which does not provide
+ * {@link rx.Observable#unsafeCreate(OnSubscribe) Observable.create(OnSubscribe)} which does not provide
  * any means of managing back pressure requests out-of-the-box.
  *
  * @param <S>
diff --git a/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index f1b897fa21..47ab6e4095 100644
--- a/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -41,7 +41,7 @@
  */
 public abstract class RxJavaObservableExecutionHook { // NOPMD
     /**
-     * Invoked during the construction by {@link Observable#create(OnSubscribe)}
+     * Invoked during the construction by {@link Observable#unsafeCreate(OnSubscribe)}
      * <p>
      * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
      * logging, metrics and other such things and pass through the function.
diff --git a/src/perf/java/rx/OneItemPerf.java b/src/perf/java/rx/OneItemPerf.java
index 43c6539992..7927268c69 100644
--- a/src/perf/java/rx/OneItemPerf.java
+++ b/src/perf/java/rx/OneItemPerf.java
@@ -70,7 +70,7 @@ public void call(SingleSubscriber<? super T> t) {
     @Setup
     public void setup() {
         scalar = Observable.just(1);
-        one = Observable.create(new OnSubscribe<Integer>() {
+        one = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
                 t.setProducer(new SingleProducer<Integer>(t, 1));
diff --git a/src/perf/java/rx/jmh/InputWithIncrementingInteger.java b/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
index 9700db74c1..24468bb97b 100644
--- a/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
+++ b/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
@@ -44,7 +44,7 @@ public void setup(final Blackhole bh) {
         final int size = getSize();
         observable = Observable.range(0, size);
 
-        firehose = Observable.create(new OnSubscribe<Integer>() {
+        firehose = Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
diff --git a/src/perf/java/rx/operators/FromComparison.java b/src/perf/java/rx/operators/FromComparison.java
index 3ba2d3c751..763a938cae 100644
--- a/src/perf/java/rx/operators/FromComparison.java
+++ b/src/perf/java/rx/operators/FromComparison.java
@@ -49,8 +49,8 @@ public void setup() {
 
         Arrays.fill(array, 1);
 
-        iterableSource = Observable.create(new OnSubscribeFromIterable<Integer>(Arrays.asList(array)));
-        arraySource = Observable.create(new OnSubscribeFromArray<Integer>(array));
+        iterableSource = Observable.unsafeCreate(new OnSubscribeFromIterable<Integer>(Arrays.asList(array)));
+        arraySource = Observable.unsafeCreate(new OnSubscribeFromArray<Integer>(array));
     }
 
     @Benchmark
diff --git a/src/perf/java/rx/operators/OperatorRangePerf.java b/src/perf/java/rx/operators/OperatorRangePerf.java
index 53e06a0c94..78711e3d58 100644
--- a/src/perf/java/rx/operators/OperatorRangePerf.java
+++ b/src/perf/java/rx/operators/OperatorRangePerf.java
@@ -43,7 +43,7 @@ public static class InputUsingRequest {
 
         @Setup
         public void setup(final Blackhole bh) {
-            observable = Observable.create(new OnSubscribeRange(0, size));
+            observable = Observable.unsafeCreate(new OnSubscribeRange(0, size));
             this.bh = bh;
         }
 
@@ -91,7 +91,7 @@ public static class InputWithoutRequest {
 
         @Setup
         public void setup(final Blackhole bh) {
-            observable = Observable.create(new OnSubscribeRange(0, size));
+            observable = Observable.unsafeCreate(new OnSubscribeRange(0, size));
             this.bh = bh;
 
         }
diff --git a/src/perf/java/rx/operators/OperatorSerializePerf.java b/src/perf/java/rx/operators/OperatorSerializePerf.java
index cae310b72c..70b61421ec 100644
--- a/src/perf/java/rx/operators/OperatorSerializePerf.java
+++ b/src/perf/java/rx/operators/OperatorSerializePerf.java
@@ -59,7 +59,7 @@ public void serializedSingleStream(Input input) throws InterruptedException {
     @Benchmark
     public void serializedTwoStreamsHighlyContended(final Input input) throws InterruptedException {
         LatchedObserver<Integer> o = input.newLatchedObserver();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -101,7 +101,7 @@ public Integer call(Long t1) {
     @Benchmark
     public void serializedTwoStreamsSlightlyContended(final InputWithInterval input) throws InterruptedException {
         LatchedObserver<Integer> o = input.newLatchedObserver();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -118,7 +118,7 @@ public void call(Subscriber<? super Integer> s) {
     @Benchmark
     public void serializedTwoStreamsOneFastOneSlow(final InputWithInterval input) throws InterruptedException {
         LatchedObserver<Integer> o = input.newLatchedObserver();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
diff --git a/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java b/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
index 3b54689c53..c96f9a2c66 100644
--- a/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
+++ b/src/perf/java/rx/operators/OperatorTakeLastOnePerf.java
@@ -46,7 +46,7 @@ public void takeLastOneUsingTakeLast(Input input) {
 
     @Benchmark
     public void takeLastOneUsingTakeLastOne(Input input) {
-       Observable.create(new OnSubscribeTakeLastOne<Integer>(input.observable)).subscribe(input.observer);
+       Observable.unsafeCreate(new OnSubscribeTakeLastOne<Integer>(input.observable)).subscribe(input.observer);
     }
 
 }
diff --git a/src/test/java/rx/BackpressureTests.java b/src/test/java/rx/BackpressureTests.java
index f9931f8754..16a1565b0a 100644
--- a/src/test/java/rx/BackpressureTests.java
+++ b/src/test/java/rx/BackpressureTests.java
@@ -593,7 +593,7 @@ private static Observable<Integer> incrementingIntegers(final AtomicInteger coun
     }
 
     private static Observable<Integer> incrementingIntegers(final AtomicInteger counter, final ConcurrentLinkedQueue<Thread> threadsSeen) {
-        return Observable.create(new OnSubscribe<Integer>() {
+        return Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             final AtomicLong requested = new AtomicLong();
 
@@ -637,7 +637,7 @@ public void request(long n) {
      * @return
      */
     private static Observable<Integer> firehose(final AtomicInteger counter) {
-        return Observable.create(new OnSubscribe<Integer>() {
+        return Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             int i;
 
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 97a40439c8..23418b60e6 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -391,7 +391,7 @@ public void call(CompletableSubscriber cs) {
                     cs.onError(e);
                 }
             })
-            .andThen(Observable.<String>create(new Observable.OnSubscribe<String>() {
+            .andThen(Observable.<String>unsafeCreate(new Observable.OnSubscribe<String>() {
                 @Override
                 public void call(Subscriber<? super String> s) {
                     hasRun.set(true);
diff --git a/src/test/java/rx/ConcatTests.java b/src/test/java/rx/ConcatTests.java
index 558f8af1dd..d00d812c52 100644
--- a/src/test/java/rx/ConcatTests.java
+++ b/src/test/java/rx/ConcatTests.java
@@ -149,7 +149,7 @@ public void testConcatCovariance4() {
         Media media = new Media();
         HorrorMovie horrorMovie2 = new HorrorMovie();
 
-        Observable<Movie> o1 = Observable.create(new OnSubscribe<Movie>() {
+        Observable<Movie> o1 = Observable.unsafeCreate(new OnSubscribe<Movie>() {
 
             @Override
             public void call(Subscriber<? super Movie> o) {
diff --git a/src/test/java/rx/EventStream.java b/src/test/java/rx/EventStream.java
index 632e649601..91a6482a5c 100644
--- a/src/test/java/rx/EventStream.java
+++ b/src/test/java/rx/EventStream.java
@@ -32,7 +32,7 @@ private EventStream() {
         throw new IllegalStateException("No instances!");
     }
     public static Observable<Event> getEventStream(final String type, final int numInstances) {
-        return Observable.create(new OnSubscribe<Event>() {
+        return Observable.unsafeCreate(new OnSubscribe<Event>() {
 
             @Override
             public void call(final Subscriber<? super Event> subscriber) {
diff --git a/src/test/java/rx/MergeTests.java b/src/test/java/rx/MergeTests.java
index 07bba783ea..c42579cc37 100644
--- a/src/test/java/rx/MergeTests.java
+++ b/src/test/java/rx/MergeTests.java
@@ -80,7 +80,7 @@ public void testMergeCovariance3() {
     @Test
     public void testMergeCovariance4() {
 
-        Observable<Movie> o1 = Observable.create(new OnSubscribe<Movie>() {
+        Observable<Movie> o1 = Observable.unsafeCreate(new OnSubscribe<Movie>() {
 
             @Override
             public void call(Subscriber<? super Movie> o) {
diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
index bed04b4cdc..1ad7daaa72 100644
--- a/src/test/java/rx/ObservableTests.java
+++ b/src/test/java/rx/ObservableTests.java
@@ -94,7 +94,7 @@ public void fromArityArgs1() {
     @Test
     public void testCreate() {
 
-        Observable<String> observable = Observable.create(new OnSubscribe<String>() {
+        Observable<String> observable = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> Observer) {
@@ -140,7 +140,7 @@ public void testCountZeroItems() {
 
     @Test
     public void testCountError() {
-        Observable<String> o = Observable.create(new OnSubscribe<String>() {
+        Observable<String> o = Observable.unsafeCreate(new OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> obsv) {
                 obsv.onError(new RuntimeException());
@@ -289,7 +289,7 @@ public void testOnSubscribeFails() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         final RuntimeException re = new RuntimeException("bad impl");
-        Observable<String> o = Observable.create(new OnSubscribe<String>() {
+        Observable<String> o = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> t1) {
@@ -330,7 +330,7 @@ public void testCustomObservableWithErrorInObserverAsynchronous() throws Interru
         final CountDownLatch latch = new CountDownLatch(1);
         final AtomicInteger count = new AtomicInteger();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        Observable.create(new OnSubscribe<String>() {
+        Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(final Subscriber<? super String> observer) {
@@ -395,7 +395,7 @@ public void onNext(String v) {
     public void testCustomObservableWithErrorInObserverSynchronous() {
         final AtomicInteger count = new AtomicInteger();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        Observable.create(new OnSubscribe<String>() {
+        Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> observer) {
@@ -445,7 +445,7 @@ public void onNext(String v) {
     public void testCustomObservableWithErrorInObservableSynchronous() {
         final AtomicInteger count = new AtomicInteger();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        Observable.create(new OnSubscribe<String>() {
+        Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> observer) {
@@ -484,7 +484,7 @@ public void onNext(String v) {
     @Test
     public void testPublishLast() throws InterruptedException {
         final AtomicInteger count = new AtomicInteger();
-        ConnectableObservable<String> connectable = Observable.create(new OnSubscribe<String>() {
+        ConnectableObservable<String> connectable = Observable.unsafeCreate(new OnSubscribe<String>() {
             @Override
             public void call(final Subscriber<? super String> observer) {
                 count.incrementAndGet();
@@ -522,7 +522,7 @@ public void call(String value) {
     @Test
     public void testReplay() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        ConnectableObservable<String> o = Observable.create(new OnSubscribe<String>() {
+        ConnectableObservable<String> o = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(final Subscriber<? super String> observer) {
@@ -577,7 +577,7 @@ public void call(String v) {
     @Test
     public void testCache() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        Observable<String> o = Observable.create(new OnSubscribe<String>() {
+        Observable<String> o = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(final Subscriber<? super String> observer) {
@@ -625,7 +625,7 @@ public void call(String v) {
     @Test
     public void testCacheWithCapacity() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        Observable<String> o = Observable.create(new OnSubscribe<String>() {
+        Observable<String> o = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(final Subscriber<? super String> observer) {
@@ -711,7 +711,7 @@ public void call(Object t1) {
     public void testErrorThrownWithoutErrorHandlerAsynchronous() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         final AtomicReference<Throwable> exception = new AtomicReference<Throwable>();
-        Observable.create(new OnSubscribe<String>() {
+        Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(final Subscriber<? super String> observer) {
@@ -1109,7 +1109,7 @@ public void testForEachWithNull() {
 
     @Test
     public void nullOnSubscribe() {
-        Observable<Integer> source = Observable.create((OnSubscribe<Integer>)null);
+        Observable<Integer> source = Observable.unsafeCreate((OnSubscribe<Integer>)null);
 
         try {
             source.subscribe();
@@ -1147,7 +1147,7 @@ public void nullSubscriber() {
     @Test
     public void testCacheHint() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        Observable<String> o = Observable.create(new OnSubscribe<String>() {
+        Observable<String> o = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(final Subscriber<? super String> observer) {
diff --git a/src/test/java/rx/SubscriberTest.java b/src/test/java/rx/SubscriberTest.java
index 5180966a1a..a57f2b0229 100644
--- a/src/test/java/rx/SubscriberTest.java
+++ b/src/test/java/rx/SubscriberTest.java
@@ -229,7 +229,7 @@ public void testRequestToObservable() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         ts.request(3);
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -252,7 +252,7 @@ public void testRequestThroughMap() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         ts.request(3);
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -282,7 +282,7 @@ public void testRequestThroughTakeThatReducesRequest() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         ts.request(3);
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -305,7 +305,7 @@ public void testRequestThroughTakeWhereRequestIsSmallerThanTake() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         ts.request(3);
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
diff --git a/src/test/java/rx/exceptions/ExceptionsTest.java b/src/test/java/rx/exceptions/ExceptionsTest.java
index 5fe0f18d69..07bcb644a8 100644
--- a/src/test/java/rx/exceptions/ExceptionsTest.java
+++ b/src/test/java/rx/exceptions/ExceptionsTest.java
@@ -254,10 +254,10 @@ public void onNext(Integer integer) {
 
     @Test(expected = OnErrorFailedException.class)
     public void testOnErrorExceptionIsThrownFromSubscribe() {
-        Observable.create(new Observable.OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
                               @Override
                               public void call(Subscriber<? super Integer> s1) {
-                                  Observable.create(new Observable.OnSubscribe<Integer>() {
+                                  Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
                                       @Override
                                       public void call(Subscriber<? super Integer> s2) {
                                           throw new IllegalArgumentException("original exception");
@@ -270,10 +270,10 @@ public void call(Subscriber<? super Integer> s2) {
 
     @Test(expected = OnErrorFailedException.class)
     public void testOnErrorExceptionIsThrownFromUnsafeSubscribe() {
-        Observable.create(new Observable.OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
                               @Override
                               public void call(Subscriber<? super Integer> s1) {
-                                  Observable.create(new Observable.OnSubscribe<Integer>() {
+                                  Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
                                       @Override
                                       public void call(Subscriber<? super Integer> s2) {
                                           throw new IllegalArgumentException("original exception");
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
index 45a109e885..4cff913cea 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
@@ -239,7 +239,7 @@ public void testNoBufferingOrBlockingOfSequence() throws Throwable {
         final CountDownLatch timeHasPassed = new CountDownLatch(COUNT);
         final AtomicBoolean running = new AtomicBoolean(true);
         final AtomicInteger count = new AtomicInteger(0);
-        final Observable<Integer> obs = Observable.create(new Observable.OnSubscribe<Integer>() {
+        final Observable<Integer> obs = Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> o) {
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java b/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
index 97d8cdb250..81f54dcdca 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorToFutureTest.java
@@ -65,7 +65,7 @@ public void testExceptionWithMoreThanOneElement() throws Throwable {
 
     @Test
     public void testToFutureWithException() {
-        Observable<String> obs = Observable.create(new OnSubscribe<String>() {
+        Observable<String> obs = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> observer) {
@@ -85,7 +85,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test(expected = CancellationException.class)
     public void testGetAfterCancel() throws Exception {
-        Observable<String> obs = Observable.create(new OperationNeverComplete<String>());
+        Observable<String> obs = Observable.unsafeCreate(new OperationNeverComplete<String>());
         Future<String> f = toFuture(obs);
         boolean cancelled = f.cancel(true);
         assertTrue(cancelled);  // because OperationNeverComplete never does
@@ -94,7 +94,7 @@ public void testGetAfterCancel() throws Exception {
 
     @Test(expected = CancellationException.class)
     public void testGetWithTimeoutAfterCancel() throws Exception {
-        Observable<String> obs = Observable.create(new OperationNeverComplete<String>());
+        Observable<String> obs = Observable.unsafeCreate(new OperationNeverComplete<String>());
         Future<String> f = toFuture(obs);
         boolean cancelled = f.cancel(true);
         assertTrue(cancelled);  // because OperationNeverComplete never does
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java b/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
index e641227f01..91902b2c77 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorToIteratorTest.java
@@ -55,7 +55,7 @@ public void testToIterator() {
 
     @Test(expected = TestException.class)
     public void testToIteratorWithException() {
-        Observable<String> obs = Observable.create(new OnSubscribe<String>() {
+        Observable<String> obs = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> observer) {
@@ -75,7 +75,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test(expected = TestException.class)
     public void testExceptionThrownFromOnSubscribe() {
-        Iterable<String> strings = Observable.create(new Observable.OnSubscribe<String>() {
+        Iterable<String> strings = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> subscriber) {
                 throw new TestException("intentional");
diff --git a/src/test/java/rx/internal/operators/CachedObservableTest.java b/src/test/java/rx/internal/operators/CachedObservableTest.java
index a642d80b03..40fe2e56de 100644
--- a/src/test/java/rx/internal/operators/CachedObservableTest.java
+++ b/src/test/java/rx/internal/operators/CachedObservableTest.java
@@ -85,7 +85,7 @@ public void testColdReplayBackpressure() {
     @Test
     public void testCache() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        Observable<String> o = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> o = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
 
             @Override
             public void call(final Subscriber<? super String> observer) {
@@ -220,7 +220,7 @@ public void testAsyncComeAndGo() {
     @Test
     public void testNoMissingBackpressureException() {
         final int m = 4 * 1000 * 1000;
-        Observable<Integer> firehose = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> firehose = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
                 for (int i = 0; i < m; i++) {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java b/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java
index c3e7480fa7..7f9bf0ff49 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeAmbTest.java
@@ -51,7 +51,7 @@ public void setUp() {
 
     private Observable<String> createObservable(final String[] values,
             final long interval, final Throwable e) {
-        return Observable.create(new OnSubscribe<String>() {
+        return Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(final Subscriber<? super String> subscriber) {
@@ -90,7 +90,7 @@ public void testAmb() {
         Observable<String> observable3 = createObservable(new String[] {
                 "3", "33", "333", "3333" }, 3000, null);
 
-        Observable<String> o = Observable.create(amb(observable1,
+        Observable<String> o = Observable.unsafeCreate(amb(observable1,
                 observable2, observable3));
 
         @SuppressWarnings("unchecked")
@@ -119,7 +119,7 @@ public void testAmb2() {
         Observable<String> observable3 = createObservable(new String[] {},
                 3000, new IOException("fake exception"));
 
-        Observable<String> o = Observable.create(amb(observable1,
+        Observable<String> o = Observable.unsafeCreate(amb(observable1,
                 observable2, observable3));
 
         @SuppressWarnings("unchecked")
@@ -146,7 +146,7 @@ public void testAmb3() {
         Observable<String> observable3 = createObservable(new String[] {
                 "3" }, 3000, null);
 
-        Observable<String> o = Observable.create(amb(observable1,
+        Observable<String> o = Observable.unsafeCreate(amb(observable1,
                 observable2, observable3));
 
         @SuppressWarnings("unchecked")
@@ -165,7 +165,7 @@ public void testProducerRequestThroughAmb() {
         ts.requestMore(3);
         final AtomicLong requested1 = new AtomicLong();
         final AtomicLong requested2 = new AtomicLong();
-        Observable<Integer> o1 = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> o1 = Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -181,7 +181,7 @@ public void request(long n) {
             }
 
         });
-        Observable<Integer> o2 = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> o2 = Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java b/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java
index 859ecd63c9..75d6b51954 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeCollectTest.java
@@ -130,7 +130,7 @@ public void call(Throwable t) {
             final RuntimeException e1 = new RuntimeException();
             final RuntimeException e2 = new RuntimeException();
             TestSubscriber<List<Integer>> ts = TestSubscriber.create();
-            Observable.create(new OnSubscribe<Integer>() {
+            Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
                 @Override
                 public void call(final Subscriber<? super Integer> sub) {
@@ -171,7 +171,7 @@ public void call(List<Integer> t1, Integer t2) {
     public void testCollectorFailureDoesNotResultInErrorAndCompletedEmissions() {
         final RuntimeException e1 = new RuntimeException();
         TestSubscriber<List<Integer>> ts = TestSubscriber.create();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -209,7 +209,7 @@ public void testCollectorFailureDoesNotResultInErrorAndOnNextEmissions() {
         final RuntimeException e1 = new RuntimeException();
         TestSubscriber<List<Integer>> ts = TestSubscriber.create();
         final AtomicBoolean added = new AtomicBoolean();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java b/src/test/java/rx/internal/operators/OnSubscribeCreateTest.java
similarity index 80%
rename from src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
rename to src/test/java/rx/internal/operators/OnSubscribeCreateTest.java
index 8298625a9b..2d8e5f843c 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromEmitterTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeCreateTest.java
@@ -32,7 +32,7 @@
 import rx.plugins.RxJavaHooks;
 import rx.subjects.PublishSubject;
 
-public class OnSubscribeFromEmitterTest {
+public class OnSubscribeCreateTest {
 
     PublishEmitter source;
 
@@ -49,7 +49,7 @@ public void before() {
 
     @Test
     public void normalBuffered() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -70,7 +70,7 @@ public void normalBuffered() {
 
     @Test
     public void normalDrop() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.DROP).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.DROP).subscribe(ts);
 
         source.onNext(1);
 
@@ -86,7 +86,7 @@ public void normalDrop() {
 
     @Test
     public void normalLatest() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.LATEST).subscribe(ts);
 
         source.onNext(1);
 
@@ -102,7 +102,7 @@ public void normalLatest() {
 
     @Test
     public void normalNone() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.NONE).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -115,7 +115,7 @@ public void normalNone() {
 
     @Test
     public void normalNoneRequested() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.NONE).subscribe(ts);
         ts.requestMore(2);
 
         source.onNext(1);
@@ -130,7 +130,7 @@ public void normalNoneRequested() {
 
     @Test
     public void normalError() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.ERROR).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.ERROR).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -140,7 +140,7 @@ public void normalError() {
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
 
-        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+        Assert.assertEquals("create: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
     }
 
     @Test
@@ -153,13 +153,13 @@ public void call(Emitter<Integer> emitter) {
                 //don't check for unsubscription
                 emitter.onNext(2);
             }};
-        Observable.fromEmitter(source, Emitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
 
         ts.assertNoValues();
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
 
-        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+        Assert.assertEquals("create: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
     }
 
     @Test
@@ -172,13 +172,13 @@ public void call(Emitter<Integer> emitter) {
                 //don't check for unsubscription
                 emitter.onCompleted();
             }};
-        Observable.fromEmitter(source, Emitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
 
         ts.assertNoValues();
         ts.assertError(MissingBackpressureException.class);
         ts.assertNotCompleted();
 
-        Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+        Assert.assertEquals("create: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
     }
 
     @Test
@@ -199,13 +199,13 @@ public void call(Emitter<Integer> emitter) {
                     //don't check for unsubscription
                     emitter.onError(e);
                 }};
-            Observable.fromEmitter(source, Emitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
+            Observable.create(source, Emitter.BackpressureMode.ERROR).unsafeSubscribe(ts);
 
             ts.assertNoValues();
             ts.assertError(MissingBackpressureException.class);
             ts.assertNotCompleted();
 
-            Assert.assertEquals("fromEmitter: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
+            Assert.assertEquals("create: could not emit value due to lack of requests", ts.getOnErrorEvents().get(0).getMessage());
             assertEquals(Arrays.asList(e), list);
         } finally {
             RxJavaHooks.reset();
@@ -214,7 +214,7 @@ public void call(Emitter<Integer> emitter) {
 
     @Test
     public void errorBuffered() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -233,7 +233,7 @@ public void errorBuffered() {
 
     @Test
     public void errorLatest() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.LATEST).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -248,7 +248,7 @@ public void errorLatest() {
 
     @Test
     public void errorNone() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.NONE).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -263,7 +263,7 @@ public void errorNone() {
 
     @Test
     public void unsubscribedBuffer() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.unsubscribe();
 
         source.onNext(1);
@@ -279,7 +279,7 @@ public void unsubscribedBuffer() {
 
     @Test
     public void unsubscribedLatest() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.LATEST).subscribe(ts);
         ts.unsubscribe();
 
         source.onNext(1);
@@ -295,7 +295,7 @@ public void unsubscribedLatest() {
 
     @Test
     public void unsubscribedError() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.ERROR).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.ERROR).subscribe(ts);
         ts.unsubscribe();
 
         source.onNext(1);
@@ -311,7 +311,7 @@ public void unsubscribedError() {
 
     @Test
     public void unsubscribedDrop() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.DROP).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.DROP).subscribe(ts);
         ts.unsubscribe();
 
         source.onNext(1);
@@ -327,7 +327,7 @@ public void unsubscribedDrop() {
 
     @Test
     public void unsubscribedNone() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.NONE).subscribe(ts);
         ts.unsubscribe();
 
         source.onNext(1);
@@ -343,7 +343,7 @@ public void unsubscribedNone() {
 
     @Test
     public void unsubscribedNoCancelBuffer() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.unsubscribe();
 
         sourceNoCancel.onNext(1);
@@ -359,7 +359,7 @@ public void unsubscribedNoCancelBuffer() {
 
     @Test
     public void unsubscribedNoCancelLatest() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
         ts.unsubscribe();
 
         sourceNoCancel.onNext(1);
@@ -375,7 +375,7 @@ public void unsubscribedNoCancelLatest() {
 
     @Test
     public void unsubscribedNoCancelError() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.ERROR).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.ERROR).subscribe(ts);
         ts.unsubscribe();
 
         sourceNoCancel.onNext(1);
@@ -391,7 +391,7 @@ public void unsubscribedNoCancelError() {
 
     @Test
     public void unsubscribedNoCancelDrop() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.DROP).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.DROP).subscribe(ts);
         ts.unsubscribe();
 
         sourceNoCancel.onNext(1);
@@ -407,7 +407,7 @@ public void unsubscribedNoCancelDrop() {
 
     @Test
     public void unsubscribedNoCancelNone() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.NONE).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.NONE).subscribe(ts);
         ts.unsubscribe();
 
         sourceNoCancel.onNext(1);
@@ -423,7 +423,7 @@ public void unsubscribedNoCancelNone() {
 
     @Test
     public void deferredRequest() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -438,7 +438,7 @@ public void deferredRequest() {
 
     @Test
     public void take() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
 
         source.onNext(1);
         source.onNext(2);
@@ -453,7 +453,7 @@ public void take() {
 
     @Test
     public void takeOne() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
         ts.requestMore(2);
 
         source.onNext(1);
@@ -467,7 +467,7 @@ public void takeOne() {
 
     @Test
     public void requestExact() {
-        Observable.fromEmitter(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.create(source, Emitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.requestMore(2);
 
         source.onNext(1);
@@ -481,7 +481,7 @@ public void requestExact() {
 
     @Test
     public void takeNoCancel() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.BUFFER).take(2).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
@@ -496,7 +496,7 @@ public void takeNoCancel() {
 
     @Test
     public void takeOneNoCancel() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.BUFFER).take(1).subscribe(ts);
         ts.requestMore(2);
 
         sourceNoCancel.onNext(1);
@@ -510,7 +510,7 @@ public void takeOneNoCancel() {
 
     @Test
     public void unsubscribeNoCancel() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
         ts.requestMore(2);
 
         sourceNoCancel.onNext(1);
@@ -535,7 +535,7 @@ public void onNext(Integer t) {
             }
         };
 
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts1);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts1);
 
         sourceNoCancel.onNext(1);
 
@@ -546,7 +546,7 @@ public void onNext(Integer t) {
 
     @Test
     public void completeInline() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
@@ -560,7 +560,7 @@ public void completeInline() {
 
     @Test
     public void errorInline() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onError(new TestException());
@@ -582,7 +582,7 @@ public void onNext(Integer t) {
             }
         };
 
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts1);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.BUFFER).subscribe(ts1);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
@@ -602,7 +602,7 @@ public void onNext(Integer t) {
             }
         };
 
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts1);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts1);
 
         sourceNoCancel.onNext(1);
 
@@ -621,7 +621,7 @@ public void onNext(Integer t) {
             }
         };
 
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts1);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts1);
 
         sourceNoCancel.onNext(1);
 
@@ -632,7 +632,7 @@ public void onNext(Integer t) {
 
     @Test
     public void completeInlineLatest() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
@@ -646,7 +646,7 @@ public void completeInlineLatest() {
 
     @Test
     public void completeInlineExactLatest() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onCompleted();
@@ -660,7 +660,7 @@ public void completeInlineExactLatest() {
 
     @Test
     public void errorInlineLatest() {
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onError(new TestException());
@@ -682,7 +682,7 @@ public void onNext(Integer t) {
             }
         };
 
-        Observable.fromEmitter(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts1);
+        Observable.create(sourceNoCancel, Emitter.BackpressureMode.LATEST).subscribe(ts1);
 
         sourceNoCancel.onNext(1);
         sourceNoCancel.onNext(2);
diff --git a/src/test/java/rx/internal/operators/OnSubscribeDetachTest.java b/src/test/java/rx/internal/operators/OnSubscribeDetachTest.java
index 6d06019425..7d435bff79 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeDetachTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeDetachTest.java
@@ -138,7 +138,7 @@ public void deferredUpstreamProducer() {
 
         TestSubscriber<Object> ts = new TestSubscriber<Object>(0);
 
-        Observable.create(new OnSubscribe<Object>() {
+        Observable.unsafeCreate(new OnSubscribe<Object>() {
             @Override
             public void call(Subscriber<? super Object> t) {
                 subscriber.set(t);
diff --git a/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java b/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
index 8cf5bdd2cc..bec5c4daab 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeDoOnEachTest.java
@@ -178,7 +178,7 @@ public void testFatalError() {
                     .flatMap(new Func1<Integer, Observable<?>>() {
                         @Override
                         public Observable<?> call(Integer integer) {
-                            return Observable.create(new Observable.OnSubscribe<Object>() {
+                            return Observable.unsafeCreate(new Observable.OnSubscribe<Object>() {
                                 @Override
                                 public void call(Subscriber<Object> o) {
                                     throw new NullPointerException("Test NPE");
@@ -229,7 +229,7 @@ public void call(Throwable e) {
     public void testIfOnNextActionFailsEmitsErrorAndDoesNotFollowWithCompleted() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
         final RuntimeException e1 = new RuntimeException();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> subscriber) {
@@ -259,7 +259,7 @@ public void call(Integer t) {
     public void testIfOnNextActionFailsEmitsErrorAndDoesNotFollowWithOnNext() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
         final RuntimeException e1 = new RuntimeException();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> subscriber) {
@@ -298,7 +298,7 @@ public void call(Throwable e) {
             TestSubscriber<Integer> ts = TestSubscriber.create();
             final RuntimeException e1 = new RuntimeException();
             final RuntimeException e2 = new RuntimeException();
-            Observable.create(new OnSubscribe<Integer>() {
+            Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
                 @Override
                 public void call(final Subscriber<? super Integer> subscriber) {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java
index cd117169d2..1d5368f097 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromArrayTest.java
@@ -29,7 +29,7 @@ Observable<Integer> create(int n) {
         for (int i = 0; i < n; i++) {
             array[i] = i;
         }
-        return Observable.create(new OnSubscribeFromArray<Integer>(array));
+        return Observable.unsafeCreate(new OnSubscribeFromArray<Integer>(array));
     }
     @Test
     public void simple() {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java b/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java
index 43993ca137..0464ed8dc0 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeFromIterableTest.java
@@ -38,12 +38,12 @@ public class OnSubscribeFromIterableTest {
 
     @Test(expected = NullPointerException.class)
     public void testNull() {
-        Observable.create(new OnSubscribeFromIterable<String>(null));
+        Observable.unsafeCreate(new OnSubscribeFromIterable<String>(null));
     }
 
     @Test
     public void testListIterable() {
-        Observable<String> observable = Observable.create(new OnSubscribeFromIterable<String>(Arrays.<String> asList("one", "two", "three")));
+        Observable<String> observable = Observable.unsafeCreate(new OnSubscribeFromIterable<String>(Arrays.<String> asList("one", "two", "three")));
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -86,7 +86,7 @@ public void remove() {
             }
 
         };
-        Observable<String> observable = Observable.create(new OnSubscribeFromIterable<String>(it));
+        Observable<String> observable = Observable.unsafeCreate(new OnSubscribeFromIterable<String>(it));
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
diff --git a/src/test/java/rx/internal/operators/OnSubscribeMapTest.java b/src/test/java/rx/internal/operators/OnSubscribeMapTest.java
index 6477bdbdc5..12c24cb303 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeMapTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeMapTest.java
@@ -299,7 +299,7 @@ public void call(Object object) {
         };
 
         try {
-            Observable.create(creator).flatMap(manyMapper).map(mapper).subscribe(onNext);
+            Observable.unsafeCreate(creator).flatMap(manyMapper).map(mapper).subscribe(onNext);
         } catch (RuntimeException e) {
             e.printStackTrace();
             throw e;
diff --git a/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java b/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
index 9ae07b6112..7d0f1a6cc3 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeReduceTest.java
@@ -145,7 +145,7 @@ public void testBackpressureWithInitialValue() throws InterruptedException {
     @Test
     public void testNoInitialValueDoesNotEmitMultipleTerminalEvents() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -176,7 +176,7 @@ public Integer call(Integer a, Integer b) {
     @Test
     public void testNoInitialValueUpstreamEmitsMoreOnNextDespiteUnsubscription() {
         TestSubscriber<Integer> ts = TestSubscriber.create();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -226,7 +226,7 @@ public void call(Throwable t) {
             TestSubscriber<Integer> ts = TestSubscriber.create();
             final RuntimeException e1 = new RuntimeException("e1");
             final Throwable e2 = new RuntimeException("e2");
-            Observable.create(new OnSubscribe<Integer>() {
+            Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
                 @Override
                 public void call(final Subscriber<? super Integer> sub) {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java b/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java
index e0761a576a..a64f808e78 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java
@@ -322,7 +322,7 @@ public void call() {
     }
 
     private Observable<Long> synchronousInterval() {
-        return Observable.create(new OnSubscribe<Long>() {
+        return Observable.unsafeCreate(new OnSubscribe<Long>() {
 
             @Override
             public void call(Subscriber<? super Long> subscriber) {
@@ -341,7 +341,7 @@ public void call(Subscriber<? super Long> subscriber) {
     public void onlyFirstShouldSubscribeAndLastUnsubscribe() {
         final AtomicInteger subscriptionCount = new AtomicInteger();
         final AtomicInteger unsubscriptionCount = new AtomicInteger();
-        Observable<Integer> observable = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> observable = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> observer) {
                 subscriptionCount.incrementAndGet();
diff --git a/src/test/java/rx/internal/operators/OnSubscribeToMapTest.java b/src/test/java/rx/internal/operators/OnSubscribeToMapTest.java
index 1ed6a542a8..97b7f33673 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeToMapTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToMapTest.java
@@ -301,7 +301,7 @@ public Map<Integer, Integer> call() {
     public void testFactoryFailureDoesNotAllowErrorAndCompletedEmissions() {
         TestSubscriber<Map<Integer, Integer>> ts = TestSubscriber.create(0);
         final RuntimeException e = new RuntimeException();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -342,7 +342,7 @@ public void call(Throwable t) {
             TestSubscriber<Map<Integer, Integer>> ts = TestSubscriber.create(0);
             final RuntimeException e1 = new RuntimeException();
             final RuntimeException e2 = new RuntimeException();
-            Observable.create(new OnSubscribe<Integer>() {
+            Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
                 @Override
                 public void call(final Subscriber<? super Integer> sub) {
@@ -377,7 +377,7 @@ public Integer call(Integer t) {
     public void testFactoryFailureDoesNotAllowErrorThenOnNextEmissions() {
         TestSubscriber<Map<Integer, Integer>> ts = TestSubscriber.create(0);
         final RuntimeException e = new RuntimeException();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeToMultimapTest.java b/src/test/java/rx/internal/operators/OnSubscribeToMultimapTest.java
index 91fb03c0be..a27c2ae662 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeToMultimapTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeToMultimapTest.java
@@ -395,7 +395,7 @@ public Collection<Integer> call(Integer k) {
     public void testKeySelectorFailureDoesNotAllowErrorAndCompletedEmissions() {
         TestSubscriber<Map<Integer, Collection<Integer>>> ts = TestSubscriber.create(0);
         final RuntimeException e = new RuntimeException();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -436,7 +436,7 @@ public void call(Throwable t) {
             TestSubscriber<Map<Integer, Collection<Integer>>> ts = TestSubscriber.create(0);
             final RuntimeException e1 = new RuntimeException();
             final RuntimeException e2 = new RuntimeException();
-            Observable.create(new OnSubscribe<Integer>() {
+            Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
                 @Override
                 public void call(final Subscriber<? super Integer> sub) {
@@ -471,7 +471,7 @@ public Integer call(Integer t) {
     public void testFactoryFailureDoesNotAllowErrorThenOnNextEmissions() {
         TestSubscriber<Map<Integer, Collection<Integer>>> ts = TestSubscriber.create(0);
         final RuntimeException e = new RuntimeException();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
diff --git a/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java b/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
index e169cbb68e..3a93d4cc8f 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeUsingTest.java
@@ -254,7 +254,7 @@ public Subscription call() {
         Func1<Subscription, Observable<Integer>> observableFactory = new Func1<Subscription, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Subscription subscription) {
-                return Observable.create(new OnSubscribe<Integer>() {
+                return Observable.unsafeCreate(new OnSubscribe<Integer>() {
                     @Override
                     public void call(Subscriber<? super Integer> t1) {
                         throw new TestException();
diff --git a/src/test/java/rx/internal/operators/OperatorAllTest.java b/src/test/java/rx/internal/operators/OperatorAllTest.java
index 0ca615d515..5ac74526fa 100644
--- a/src/test/java/rx/internal/operators/OperatorAllTest.java
+++ b/src/test/java/rx/internal/operators/OperatorAllTest.java
@@ -186,7 +186,7 @@ public Boolean call(Object object) {
     @Test
     public void testDoesNotEmitMultipleTerminalEvents() {
         TestSubscriber<Boolean> ts = TestSubscriber.create();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -216,7 +216,7 @@ public Boolean call(Integer t) {
     @Test
     public void testUpstreamEmitsOnNextAfterFailureWithoutCheckingSubscription() {
         TestSubscriber<Boolean> ts = TestSubscriber.create();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -263,7 +263,7 @@ public void call(Throwable t) {
             TestSubscriber<Boolean> ts = TestSubscriber.create();
             final RuntimeException e1 = new RuntimeException();
             final Throwable e2 = new RuntimeException();
-            Observable.create(new OnSubscribe<Integer>() {
+            Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
                 @Override
                 public void call(final Subscriber<? super Integer> sub) {
diff --git a/src/test/java/rx/internal/operators/OperatorAnyTest.java b/src/test/java/rx/internal/operators/OperatorAnyTest.java
index 776d6e8f72..0eaf6b07ec 100644
--- a/src/test/java/rx/internal/operators/OperatorAnyTest.java
+++ b/src/test/java/rx/internal/operators/OperatorAnyTest.java
@@ -278,7 +278,7 @@ public Boolean call(Object object) {
     @Test
     public void testUpstreamEmitsOnNextAfterFailureWithoutCheckingSubscription() {
         TestSubscriber<Boolean> ts = TestSubscriber.create();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -314,7 +314,7 @@ public Boolean call(Integer t) {
     @Test
     public void testUpstreamEmitsOnNextWithoutCheckingSubscription() {
         TestSubscriber<Boolean> ts = TestSubscriber.create();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -356,7 +356,7 @@ public void call(Throwable t) {
             TestSubscriber<Boolean> ts = TestSubscriber.create();
             final RuntimeException e1 = new RuntimeException();
             final Throwable e2 = new RuntimeException();
-            Observable.create(new OnSubscribe<Integer>() {
+            Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
                 @Override
                 public void call(final Subscriber<? super Integer> sub) {
diff --git a/src/test/java/rx/internal/operators/OperatorBufferTest.java b/src/test/java/rx/internal/operators/OperatorBufferTest.java
index 99f4cf5c0f..5cd3b2fa96 100644
--- a/src/test/java/rx/internal/operators/OperatorBufferTest.java
+++ b/src/test/java/rx/internal/operators/OperatorBufferTest.java
@@ -52,7 +52,7 @@ public void before() {
 
     @Test
     public void testComplete() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 observer.onCompleted();
@@ -69,7 +69,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testSkipAndCountOverlappingBuffers() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
@@ -94,7 +94,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testSkipAndCountGaplessBuffers() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
@@ -119,7 +119,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testSkipAndCountBuffersWithGaps() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
@@ -144,7 +144,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testTimedAndCount() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
@@ -175,7 +175,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testTimed() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 97);
@@ -208,7 +208,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testObservableBasedOpenerAndCloser() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
@@ -220,7 +220,7 @@ public void call(Subscriber<? super String> observer) {
             }
         });
 
-        Observable<Object> openings = Observable.create(new Observable.OnSubscribe<Object>() {
+        Observable<Object> openings = Observable.unsafeCreate(new Observable.OnSubscribe<Object>() {
             @Override
             public void call(Subscriber<Object> observer) {
                 push(observer, new Object(), 50);
@@ -232,7 +232,7 @@ public void call(Subscriber<Object> observer) {
         Func1<Object, Observable<Object>> closer = new Func1<Object, Observable<Object>>() {
             @Override
             public Observable<Object> call(Object opening) {
-                return Observable.create(new Observable.OnSubscribe<Object>() {
+                return Observable.unsafeCreate(new Observable.OnSubscribe<Object>() {
                     @Override
                     public void call(Subscriber<? super Object> observer) {
                         push(observer, new Object(), 100);
@@ -256,7 +256,7 @@ public void call(Subscriber<? super Object> observer) {
 
     @Test
     public void testObservableBasedCloser() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
@@ -271,7 +271,7 @@ public void call(Subscriber<? super String> observer) {
         Func0<Observable<Object>> closer = new Func0<Observable<Object>>() {
             @Override
             public Observable<Object> call() {
-                return Observable.create(new Observable.OnSubscribe<Object>() {
+                return Observable.unsafeCreate(new Observable.OnSubscribe<Object>() {
                     @Override
                     public void call(Subscriber<? super Object> observer) {
                         push(observer, new Object(), 100);
@@ -786,7 +786,7 @@ public void testProducerRequestThroughBufferWithSize1() {
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
         ts.requestMore(3);
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new Observable.OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -811,7 +811,7 @@ public void request(long n) {
     public void testProducerRequestThroughBufferWithSize2() {
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new Observable.OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -834,7 +834,7 @@ public void testProducerRequestThroughBufferWithSize3() {
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
         ts.requestMore(3);
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new Observable.OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -858,7 +858,7 @@ public void request(long n) {
     public void testProducerRequestThroughBufferWithSize4() {
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new Observable.OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -882,7 +882,7 @@ public void testProducerRequestOverflowThroughBufferWithSize1() {
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
         ts.requestMore(Long.MAX_VALUE / 2);
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new Observable.OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -905,7 +905,7 @@ public void testProducerRequestOverflowThroughBufferWithSize2() {
         TestSubscriber<List<Integer>> ts = new TestSubscriber<List<Integer>>();
         ts.requestMore(Long.MAX_VALUE / 2);
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new Observable.OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -926,7 +926,7 @@ public void request(long n) {
     @Test
     public void testProducerRequestOverflowThroughBufferWithSize3() {
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new Observable.OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
diff --git a/src/test/java/rx/internal/operators/OperatorConcatTest.java b/src/test/java/rx/internal/operators/OperatorConcatTest.java
index 564eb9e709..1e818accda 100644
--- a/src/test/java/rx/internal/operators/OperatorConcatTest.java
+++ b/src/test/java/rx/internal/operators/OperatorConcatTest.java
@@ -115,7 +115,7 @@ public void testConcatObservableOfObservables() {
         final Observable<String> odds = Observable.from(o);
         final Observable<String> even = Observable.from(e);
 
-        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> observableOfObservables = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
 
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
@@ -144,7 +144,7 @@ public void testSimpleAsyncConcat() {
         TestObservable<String> o1 = new TestObservable<String>("one", "two", "three");
         TestObservable<String> o2 = new TestObservable<String>("four", "five", "six");
 
-        Observable.concat(Observable.create(o1), Observable.create(o2)).subscribe(observer);
+        Observable.concat(Observable.unsafeCreate(o1), Observable.unsafeCreate(o2)).subscribe(observer);
 
         try {
             // wait for async observables to complete
@@ -179,7 +179,7 @@ public void testNestedAsyncConcat() throws Throwable {
 
         final AtomicReference<Thread> parent = new AtomicReference<Thread>();
         final CountDownLatch parentHasStarted = new CountDownLatch(1);
-        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> observableOfObservables = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
 
             @Override
             public void call(final Subscriber<? super Observable<String>> observer) {
@@ -193,12 +193,12 @@ public void run() {
                             // emit first
                             if (!s.isUnsubscribed()) {
                                 System.out.println("Emit o1");
-                                observer.onNext(Observable.create(o1));
+                                observer.onNext(Observable.unsafeCreate(o1));
                             }
                             // emit second
                             if (!s.isUnsubscribed()) {
                                 System.out.println("Emit o2");
-                                observer.onNext(Observable.create(o2));
+                                observer.onNext(Observable.unsafeCreate(o2));
                             }
 
                             // wait until sometime later and emit third
@@ -209,7 +209,7 @@ public void run() {
                             }
                             if (!s.isUnsubscribed()) {
                                 System.out.println("Emit o3");
-                                observer.onNext(Observable.create(o3));
+                                observer.onNext(Observable.unsafeCreate(o3));
                             }
 
                         } catch (Throwable e) {
@@ -285,7 +285,7 @@ public void testBlockedObservableOfObservables() {
         final CountDownLatch callOnce = new CountDownLatch(1);
         final CountDownLatch okToContinue = new CountDownLatch(1);
         TestObservable<Observable<String>> observableOfObservables = new TestObservable<Observable<String>>(callOnce, okToContinue, odds, even);
-        Observable<String> concatF = Observable.concat(Observable.create(observableOfObservables));
+        Observable<String> concatF = Observable.concat(Observable.unsafeCreate(observableOfObservables));
         concatF.subscribe(observer);
         try {
             //Block main thread to allow observables to serve up o1.
@@ -323,8 +323,8 @@ public void testConcatConcurrentWithInfinity() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         @SuppressWarnings("unchecked")
-        TestObservable<Observable<String>> observableOfObservables = new TestObservable<Observable<String>>(Observable.create(w1), Observable.create(w2));
-        Observable<String> concatF = Observable.concat(Observable.create(observableOfObservables));
+        TestObservable<Observable<String>> observableOfObservables = new TestObservable<Observable<String>>(Observable.unsafeCreate(w1), Observable.unsafeCreate(w2));
+        Observable<String> concatF = Observable.concat(Observable.unsafeCreate(observableOfObservables));
 
         concatF.take(50).subscribe(observer);
 
@@ -357,13 +357,13 @@ public void testConcatNonBlockingObservables() {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> observableOfObservables = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
 
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
                 // simulate what would happen in an observable
-                observer.onNext(Observable.create(w1));
-                observer.onNext(Observable.create(w2));
+                observer.onNext(Observable.unsafeCreate(w1));
+                observer.onNext(Observable.unsafeCreate(w2));
                 observer.onCompleted();
             }
 
@@ -408,7 +408,7 @@ public void testConcatUnsubscribe() {
         @SuppressWarnings("unchecked")
         final Observer<String> observer = mock(Observer.class);
 
-        final Observable<String> concat = Observable.concat(Observable.create(w1), Observable.create(w2));
+        final Observable<String> concat = Observable.concat(Observable.unsafeCreate(w1), Observable.unsafeCreate(w2));
 
         try {
             // Subscribe
@@ -450,8 +450,8 @@ public void testConcatUnsubscribeConcurrent() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         @SuppressWarnings("unchecked")
-        TestObservable<Observable<String>> observableOfObservables = new TestObservable<Observable<String>>(Observable.create(w1), Observable.create(w2));
-        Observable<String> concatF = Observable.concat(Observable.create(observableOfObservables));
+        TestObservable<Observable<String>> observableOfObservables = new TestObservable<Observable<String>>(Observable.unsafeCreate(w1), Observable.unsafeCreate(w2));
+        Observable<String> concatF = Observable.concat(Observable.unsafeCreate(observableOfObservables));
 
         Subscription s1 = concatF.subscribe(observer);
 
@@ -618,7 +618,7 @@ public void testMultipleObservers() {
     @Test
     public void concatVeryLongObservableOfObservables() {
         final int n = 10000;
-        Observable<Observable<Integer>> source = Observable.create(new OnSubscribe<Observable<Integer>>() {
+        Observable<Observable<Integer>> source = Observable.unsafeCreate(new OnSubscribe<Observable<Integer>>() {
             @Override
             public void call(Subscriber<? super Observable<Integer>> s) {
                 for (int i = 0; i < n; i++) {
@@ -650,7 +650,7 @@ public void call(Subscriber<? super Observable<Integer>> s) {
     @Test
     public void concatVeryLongObservableOfObservablesTakeHalf() {
         final int n = 10000;
-        Observable<Observable<Integer>> source = Observable.create(new OnSubscribe<Observable<Integer>>() {
+        Observable<Observable<Integer>> source = Observable.unsafeCreate(new OnSubscribe<Observable<Integer>>() {
             @Override
             public void call(Subscriber<? super Observable<Integer>> s) {
                 for (int i = 0; i < n; i++) {
@@ -724,7 +724,7 @@ public void testInnerBackpressureWithoutAlignedBoundaries() {
     // https://github.com/ReactiveX/RxJava/issues/1818
     @Test
     public void testConcatWithNonCompliantSourceDoubleOnComplete() {
-        Observable<String> o = Observable.create(new OnSubscribe<String>() {
+        Observable<String> o = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> s) {
diff --git a/src/test/java/rx/internal/operators/OperatorDebounceTest.java b/src/test/java/rx/internal/operators/OperatorDebounceTest.java
index ae509c743d..bf3cad52d5 100644
--- a/src/test/java/rx/internal/operators/OperatorDebounceTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDebounceTest.java
@@ -57,7 +57,7 @@ public void before() {
 
     @Test
     public void testDebounceWithCompleted() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 publishNext(observer, 100, "one");    // Should be skipped since "two" will arrive before the timeout expires.
@@ -82,7 +82,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testDebounceNeverEmits() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 // all should be skipped since they are happening faster than the 200ms timeout
@@ -111,7 +111,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testDebounceWithError() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 Exception error = new TestException();
diff --git a/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java b/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
index e471376e93..d1ddd22c85 100644
--- a/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDoOnRequestTest.java
@@ -99,7 +99,7 @@ public void dontRequestIfDownstreamRequestsLate() {
 
         final AtomicReference<Producer> producer = new AtomicReference<Producer>();
 
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
                 t.setProducer(new Producer() {
diff --git a/src/test/java/rx/internal/operators/OperatorDoOnSubscribeTest.java b/src/test/java/rx/internal/operators/OperatorDoOnSubscribeTest.java
index 4765a5dfe3..2f60a9e8c5 100644
--- a/src/test/java/rx/internal/operators/OperatorDoOnSubscribeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorDoOnSubscribeTest.java
@@ -76,7 +76,7 @@ public void testDoOnUnSubscribeWorksWithRefCount() throws Exception {
         final AtomicInteger countBefore = new AtomicInteger();
         final AtomicInteger countAfter = new AtomicInteger();
         final AtomicReference<Subscriber<? super Integer>> sref = new AtomicReference<Subscriber<? super Integer>>();
-        Observable<Integer> o = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> o = Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
diff --git a/src/test/java/rx/internal/operators/OperatorGroupByTest.java b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
index 1cad5330c3..5d035bcd82 100644
--- a/src/test/java/rx/internal/operators/OperatorGroupByTest.java
+++ b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
@@ -189,7 +189,7 @@ public void testGroupedEventStream() throws Throwable {
         final int count = 100;
         final int groupCount = 2;
 
-        Observable<Event> es = Observable.create(new Observable.OnSubscribe<Event>() {
+        Observable<Event> es = Observable.unsafeCreate(new Observable.OnSubscribe<Event>() {
 
             @Override
             public void call(final Subscriber<? super Event> observer) {
@@ -602,7 +602,7 @@ public void call(String s) {
     public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsAndThenComplete() throws InterruptedException {
         final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
         final ArrayList<String> results = new ArrayList<String>();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> sub) {
@@ -680,7 +680,7 @@ public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSu
         System.err.println("----------------------------------------------------------------------------------------------");
         final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
         final ArrayList<String> results = new ArrayList<String>();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> sub) {
@@ -771,7 +771,7 @@ public void call(String s) {
     public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenObservesOnAndDelaysAndThenCompletes() throws InterruptedException {
         final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
         final ArrayList<String> results = new ArrayList<String>();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> sub) {
@@ -847,7 +847,7 @@ public void call(String s) {
     @Test
     public void testGroupsWithNestedSubscribeOn() throws InterruptedException {
         final ArrayList<String> results = new ArrayList<String>();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> sub) {
@@ -903,7 +903,7 @@ public void call(String s) {
     @Test
     public void testGroupsWithNestedObserveOn() throws InterruptedException {
         final ArrayList<String> results = new ArrayList<String>();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> sub) {
@@ -963,7 +963,7 @@ Observable<Event> ASYNC_INFINITE_OBSERVABLE_OF_EVENT(final int numGroups, final
     }
 
     Observable<Event> SYNC_INFINITE_OBSERVABLE_OF_EVENT(final int numGroups, final AtomicInteger subscribeCounter, final AtomicInteger sentEventCounter) {
-        return Observable.create(new OnSubscribe<Event>() {
+        return Observable.unsafeCreate(new OnSubscribe<Event>() {
 
             @Override
             public void call(final Subscriber<? super Event> op) {
@@ -1375,7 +1375,7 @@ public void call(String s) {
     @Test
     public void testGroupByUnsubscribe() {
         final Subscription s = mock(Subscription.class);
-        Observable<Integer> o = Observable.create(
+        Observable<Integer> o = Observable.unsafeCreate(
                 new OnSubscribe<Integer>() {
                     @Override
                     public void call(Subscriber<? super Integer> subscriber) {
@@ -1419,7 +1419,7 @@ public void onNext(GroupedObservable<Integer, Integer> o) {
                 }
             }
         });
-        Observable.create(
+        Observable.unsafeCreate(
                 new OnSubscribe<Integer>() {
                     @Override
                     public void call(Subscriber<? super Integer> subscriber) {
diff --git a/src/test/java/rx/internal/operators/OperatorMaterializeTest.java b/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
index af090b4379..437593d313 100644
--- a/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
@@ -43,7 +43,7 @@ public void testMaterialize1() {
                 "three");
 
         TestObserver Observer = new TestObserver();
-        Observable<Notification<String>> m = Observable.create(o1).materialize();
+        Observable<Notification<String>> m = Observable.unsafeCreate(o1).materialize();
         m.subscribe(Observer);
 
         try {
@@ -69,7 +69,7 @@ public void testMaterialize2() {
         final TestAsyncErrorObservable o1 = new TestAsyncErrorObservable("one", "two", "three");
 
         TestObserver Observer = new TestObserver();
-        Observable<Notification<String>> m = Observable.create(o1).materialize();
+        Observable<Notification<String>> m = Observable.unsafeCreate(o1).materialize();
         m.subscribe(Observer);
 
         try {
@@ -94,7 +94,7 @@ public void testMaterialize2() {
     public void testMultipleSubscribes() throws InterruptedException, ExecutionException {
         final TestAsyncErrorObservable o = new TestAsyncErrorObservable("one", "two", null, "three");
 
-        Observable<Notification<String>> m = Observable.create(o).materialize();
+        Observable<Notification<String>> m = Observable.unsafeCreate(o).materialize();
 
         assertEquals(3, m.toList().toBlocking().toFuture().get().size());
         assertEquals(3, m.toList().toBlocking().toFuture().get().size());
diff --git a/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java b/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java
index 7943e30dee..05326cf75a 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeDelayErrorTest.java
@@ -55,8 +55,8 @@ public void before() {
 
     @Test
     public void testErrorDelayed1() {
-        final Observable<String> o1 = Observable.create(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
-        final Observable<String> o2 = Observable.create(new TestErrorObservable("one", "two", "three"));
+        final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
+        final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three"));
 
         Observable<String> m = Observable.mergeDelayError(o1, o2);
         m.subscribe(stringObserver);
@@ -76,10 +76,10 @@ public void testErrorDelayed1() {
 
     @Test
     public void testErrorDelayed2() {
-        final Observable<String> o1 = Observable.create(new TestErrorObservable("one", "two", "three"));
-        final Observable<String> o2 = Observable.create(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
-        final Observable<String> o3 = Observable.create(new TestErrorObservable("seven", "eight", null));
-        final Observable<String> o4 = Observable.create(new TestErrorObservable("nine"));
+        final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three"));
+        final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
+        final Observable<String> o3 = Observable.unsafeCreate(new TestErrorObservable("seven", "eight", null));
+        final Observable<String> o4 = Observable.unsafeCreate(new TestErrorObservable("nine"));
 
         Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
         m.subscribe(stringObserver);
@@ -101,10 +101,10 @@ public void testErrorDelayed2() {
 
     @Test
     public void testErrorDelayed3() {
-        final Observable<String> o1 = Observable.create(new TestErrorObservable("one", "two", "three"));
-        final Observable<String> o2 = Observable.create(new TestErrorObservable("four", "five", "six"));
-        final Observable<String> o3 = Observable.create(new TestErrorObservable("seven", "eight", null));
-        final Observable<String> o4 = Observable.create(new TestErrorObservable("nine"));
+        final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three"));
+        final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("four", "five", "six"));
+        final Observable<String> o3 = Observable.unsafeCreate(new TestErrorObservable("seven", "eight", null));
+        final Observable<String> o4 = Observable.unsafeCreate(new TestErrorObservable("nine"));
 
         Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
         m.subscribe(stringObserver);
@@ -124,10 +124,10 @@ public void testErrorDelayed3() {
 
     @Test
     public void testErrorDelayed4() {
-        final Observable<String> o1 = Observable.create(new TestErrorObservable("one", "two", "three"));
-        final Observable<String> o2 = Observable.create(new TestErrorObservable("four", "five", "six"));
-        final Observable<String> o3 = Observable.create(new TestErrorObservable("seven", "eight"));
-        final Observable<String> o4 = Observable.create(new TestErrorObservable("nine", null));
+        final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three"));
+        final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("four", "five", "six"));
+        final Observable<String> o3 = Observable.unsafeCreate(new TestErrorObservable("seven", "eight"));
+        final Observable<String> o4 = Observable.unsafeCreate(new TestErrorObservable("nine", null));
 
         Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
         m.subscribe(stringObserver);
@@ -153,7 +153,7 @@ public void testErrorDelayed4WithThreading() {
         // throw the error at the very end so no onComplete will be called after it
         final TestAsyncErrorObservable o4 = new TestAsyncErrorObservable("nine", null);
 
-        Observable<String> m = Observable.mergeDelayError(Observable.create(o1), Observable.create(o2), Observable.create(o3), Observable.create(o4));
+        Observable<String> m = Observable.mergeDelayError(Observable.unsafeCreate(o1), Observable.unsafeCreate(o2), Observable.unsafeCreate(o3), Observable.unsafeCreate(o4));
         m.subscribe(stringObserver);
 
         try {
@@ -180,8 +180,8 @@ public void testErrorDelayed4WithThreading() {
 
     @Test
     public void testCompositeErrorDelayed1() {
-        final Observable<String> o1 = Observable.create(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
-        final Observable<String> o2 = Observable.create(new TestErrorObservable("one", "two", null));
+        final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
+        final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("one", "two", null));
 
         Observable<String> m = Observable.mergeDelayError(o1, o2);
         m.subscribe(stringObserver);
@@ -200,8 +200,8 @@ public void testCompositeErrorDelayed1() {
 
     @Test
     public void testCompositeErrorDelayed2() {
-        final Observable<String> o1 = Observable.create(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
-        final Observable<String> o2 = Observable.create(new TestErrorObservable("one", "two", null));
+        final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
+        final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("one", "two", null));
 
         Observable<String> m = Observable.mergeDelayError(o1, o2);
         CaptureObserver w = new CaptureObserver();
@@ -223,10 +223,10 @@ public void testCompositeErrorDelayed2() {
 
     @Test
     public void testMergeObservableOfObservables() {
-        final Observable<String> o1 = Observable.create(new TestSynchronousObservable());
-        final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
+        final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
+        final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
 
-        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> observableOfObservables = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
 
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
@@ -247,8 +247,8 @@ public void call(Subscriber<? super Observable<String>> observer) {
 
     @Test
     public void testMergeArray() {
-        final Observable<String> o1 = Observable.create(new TestSynchronousObservable());
-        final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
+        final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
+        final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
 
         Observable<String> m = Observable.mergeDelayError(o1, o2);
         m.subscribe(stringObserver);
@@ -260,8 +260,8 @@ public void testMergeArray() {
 
     @Test
     public void testMergeList() {
-        final Observable<String> o1 = Observable.create(new TestSynchronousObservable());
-        final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
+        final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
+        final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
         List<Observable<String>> listOfObservables = new ArrayList<Observable<String>>();
         listOfObservables.add(o1);
         listOfObservables.add(o2);
@@ -277,8 +277,8 @@ public void testMergeList() {
     // This is pretty much a clone of testMergeList but with the overloaded MergeDelayError for Iterables
     @Test
     public void mergeIterable() {
-        final Observable<String> o1 = Observable.create(new TestSynchronousObservable());
-        final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
+        final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
+        final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
         List<Observable<String>> listOfObservables = new ArrayList<Observable<String>>();
         listOfObservables.add(o1);
         listOfObservables.add(o2);
@@ -296,7 +296,7 @@ public void testMergeArrayWithThreading() {
         final TestASynchronousObservable o1 = new TestASynchronousObservable();
         final TestASynchronousObservable o2 = new TestASynchronousObservable();
 
-        Observable<String> m = Observable.mergeDelayError(Observable.create(o1), Observable.create(o2));
+        Observable<String> m = Observable.mergeDelayError(Observable.unsafeCreate(o1), Observable.unsafeCreate(o2));
         m.subscribe(stringObserver);
 
         try {
@@ -455,7 +455,7 @@ public void onNext(String args) {
     }
     @Test
     public void testMergeSourceWhichDoesntPropagateExceptionBack() {
-        Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> source = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t1) {
                 try {
@@ -527,11 +527,11 @@ public void testErrorInParentObservableDelayed() throws Exception {
         for (int i = 0; i < 50; i++) {
             final TestASynchronous1sDelayedObservable o1 = new TestASynchronous1sDelayedObservable();
             final TestASynchronous1sDelayedObservable o2 = new TestASynchronous1sDelayedObservable();
-            Observable<Observable<String>> parentObservable = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+            Observable<Observable<String>> parentObservable = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
                 @Override
                 public void call(Subscriber<? super Observable<String>> op) {
-                    op.onNext(Observable.create(o1));
-                    op.onNext(Observable.create(o2));
+                    op.onNext(Observable.unsafeCreate(o1));
+                    op.onNext(Observable.unsafeCreate(o2));
                     op.onError(new NullPointerException("throwing exception in parent"));
                 }
             });
diff --git a/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java b/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
index 56685b1630..21ce364b34 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
@@ -72,7 +72,7 @@ public void testMaxConcurrent() {
             for (int i = 0; i < observableCount; i++) {
                 SubscriptionCheckObservable sco = new SubscriptionCheckObservable(subscriptionCount, maxConcurrent);
                 scos.add(sco);
-                os.add(Observable.create(sco));
+                os.add(Observable.unsafeCreate(sco));
             }
 
             Iterator<String> iter = Observable.merge(os, maxConcurrent).toBlocking().toIterable().iterator();
diff --git a/src/test/java/rx/internal/operators/OperatorMergeTest.java b/src/test/java/rx/internal/operators/OperatorMergeTest.java
index d79649667d..7528cb88d8 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeTest.java
@@ -53,10 +53,10 @@ public void before() {
 
     @Test
     public void testMergeObservableOfObservables() {
-        final Observable<String> o1 = Observable.create(new TestSynchronousObservable());
-        final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
+        final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
+        final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
 
-        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> observableOfObservables = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
 
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
@@ -77,8 +77,8 @@ public void call(Subscriber<? super Observable<String>> observer) {
 
     @Test
     public void testMergeArray() {
-        final Observable<String> o1 = Observable.create(new TestSynchronousObservable());
-        final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
+        final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
+        final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
 
         Observable<String> m = Observable.merge(o1, o2);
         m.subscribe(stringObserver);
@@ -90,8 +90,8 @@ public void testMergeArray() {
 
     @Test
     public void testMergeList() {
-        final Observable<String> o1 = Observable.create(new TestSynchronousObservable());
-        final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
+        final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
+        final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
         List<Observable<String>> listOfObservables = new ArrayList<Observable<String>>();
         listOfObservables.add(o1);
         listOfObservables.add(o2);
@@ -110,7 +110,7 @@ public void testUnSubscribeObservableOfObservables() throws InterruptedException
         final AtomicBoolean unsubscribed = new AtomicBoolean();
         final CountDownLatch latch = new CountDownLatch(1);
 
-        Observable<Observable<Long>> source = Observable.create(new Observable.OnSubscribe<Observable<Long>>() {
+        Observable<Observable<Long>> source = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<Long>>() {
 
             @Override
             public void call(final Subscriber<? super Observable<Long>> observer) {
@@ -172,7 +172,7 @@ public void testMergeArrayWithThreading() {
         final TestASynchronousObservable o1 = new TestASynchronousObservable();
         final TestASynchronousObservable o2 = new TestASynchronousObservable();
 
-        Observable<String> m = Observable.merge(Observable.create(o1), Observable.create(o2));
+        Observable<String> m = Observable.merge(Observable.unsafeCreate(o1), Observable.unsafeCreate(o2));
         TestSubscriber<String> ts = new TestSubscriber<String>(stringObserver);
         m.subscribe(ts);
 
@@ -195,7 +195,7 @@ public void testSynchronizationOfMultipleSequences() throws Throwable {
         final AtomicInteger concurrentCounter = new AtomicInteger();
         final AtomicInteger totalCounter = new AtomicInteger();
 
-        Observable<String> m = Observable.merge(Observable.create(o1), Observable.create(o2));
+        Observable<String> m = Observable.merge(Observable.unsafeCreate(o1), Observable.unsafeCreate(o2));
         m.subscribe(new Subscriber<String>() {
 
             @Override
@@ -262,8 +262,8 @@ public void onNext(String v) {
     @Test
     public void testError1() {
         // we are using synchronous execution to test this exactly rather than non-deterministic concurrent behavior
-        final Observable<String> o1 = Observable.create(new TestErrorObservable("four", null, "six")); // we expect to lose "six"
-        final Observable<String> o2 = Observable.create(new TestErrorObservable("one", "two", "three")); // we expect to lose all of these since o1 is done first and fails
+        final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six"
+        final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three")); // we expect to lose all of these since o1 is done first and fails
 
         Observable<String> m = Observable.merge(o1, o2);
         m.subscribe(stringObserver);
@@ -284,10 +284,10 @@ public void testError1() {
     @Test
     public void testError2() {
         // we are using synchronous execution to test this exactly rather than non-deterministic concurrent behavior
-        final Observable<String> o1 = Observable.create(new TestErrorObservable("one", "two", "three"));
-        final Observable<String> o2 = Observable.create(new TestErrorObservable("four", null, "six")); // we expect to lose "six"
-        final Observable<String> o3 = Observable.create(new TestErrorObservable("seven", "eight", null));// we expect to lose all of these since o2 is done first and fails
-        final Observable<String> o4 = Observable.create(new TestErrorObservable("nine"));// we expect to lose all of these since o2 is done first and fails
+        final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three"));
+        final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six"
+        final Observable<String> o3 = Observable.unsafeCreate(new TestErrorObservable("seven", "eight", null));// we expect to lose all of these since o2 is done first and fails
+        final Observable<String> o4 = Observable.unsafeCreate(new TestErrorObservable("nine"));// we expect to lose all of these since o2 is done first and fails
 
         Observable<String> m = Observable.merge(o1, o2, o3, o4);
         m.subscribe(stringObserver);
@@ -308,7 +308,7 @@ public void testError2() {
     @Test
     public void testThrownErrorHandling() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
-        Observable<String> o1 = Observable.create(new OnSubscribe<String>() {
+        Observable<String> o1 = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> s) {
@@ -460,7 +460,7 @@ public void testEarlyUnsubscribe() {
     }
 
     private Observable<Long> createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(final Scheduler scheduler, final AtomicBoolean unsubscribed) {
-        return Observable.create(new OnSubscribe<Long>() {
+        return Observable.unsafeCreate(new OnSubscribe<Long>() {
 
             @Override
             public void call(Subscriber<? super Long> s) {
@@ -499,7 +499,7 @@ public void testConcurrency() {
     @Test
     public void testConcurrencyWithSleeping() {
 
-        Observable<Integer> o = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> o = Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
@@ -543,7 +543,7 @@ public void call() {
 
     @Test
     public void testConcurrencyWithBrokenOnCompleteContract() {
-        Observable<Integer> o = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> o = Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
@@ -807,7 +807,7 @@ public void mergeWithNullValues() {
     public void mergeWithTerminalEventAfterUnsubscribe() {
         System.out.println("mergeWithTerminalEventAfterUnsubscribe");
         TestSubscriber<String> ts = new TestSubscriber<String>();
-        Observable<String> bad = Observable.create(new OnSubscribe<String>() {
+        Observable<String> bad = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> s) {
@@ -984,7 +984,7 @@ public void mergeManyAsyncSingle() {
 
             @Override
             public Observable<Integer> call(final Integer i) {
-                return Observable.create(new OnSubscribe<Integer>() {
+                return Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
                     @Override
                     public void call(Subscriber<? super Integer> s) {
diff --git a/src/test/java/rx/internal/operators/OperatorObserveOnTest.java b/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
index c5a29e04a2..df2e21e5c8 100644
--- a/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorObserveOnTest.java
@@ -526,7 +526,7 @@ public boolean hasNext() {
     @Test
     public void testQueueFullEmitsError() {
         final CountDownLatch latch = new CountDownLatch(1);
-        Observable<Integer> observable = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> observable = Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> o) {
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
index ea48f2847e..b76405b12c 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureBufferTest.java
@@ -227,7 +227,7 @@ public void onNext(T t) {
         });
     }
 
-    static final Observable<Long> infinite = Observable.create(new OnSubscribe<Long>() {
+    static final Observable<Long> infinite = Observable.unsafeCreate(new OnSubscribe<Long>() {
 
         @Override
         public void call(Subscriber<? super Long> s) {
diff --git a/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java b/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
index 87d748e2ea..07174570b5 100644
--- a/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnBackpressureDropTest.java
@@ -151,7 +151,7 @@ public void testOnDropMethodIsCalled() {
         final List<Integer> list = new ArrayList<Integer>();
         // request 0
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -180,7 +180,7 @@ public void call(Integer t) {
     public void testUpstreamEmitsOnCompletedAfterFailureWithoutCheckingSubscription() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
         final RuntimeException e = new RuntimeException();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -221,7 +221,7 @@ public void call(Throwable t) {
             TestSubscriber<Integer> ts = TestSubscriber.create(0);
             final RuntimeException e1 = new RuntimeException();
             final RuntimeException e2 = new RuntimeException();
-            Observable.create(new OnSubscribe<Integer>() {
+            Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
                 @Override
                 public void call(final Subscriber<? super Integer> sub) {
@@ -255,7 +255,7 @@ public void call(Integer t) {
     public void testUpstreamEmitsOnNextAfterFailureWithoutCheckingSubscription() {
         TestSubscriber<Integer> ts = TestSubscriber.create(0);
         final RuntimeException e = new RuntimeException();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> sub) {
@@ -291,7 +291,7 @@ public void call(Long n) {
         }
     };
 
-    static final Observable<Long> infinite = Observable.create(new OnSubscribe<Long>() {
+    static final Observable<Long> infinite = Observable.unsafeCreate(new OnSubscribe<Long>() {
 
         @Override
         public void call(Subscriber<? super Long> s) {
@@ -304,7 +304,7 @@ public void call(Subscriber<? super Long> s) {
     });
 
     private static final Observable<Long> range(final long n) {
-        return Observable.create(new OnSubscribe<Long>() {
+        return Observable.unsafeCreate(new OnSubscribe<Long>() {
 
             @Override
             public void call(Subscriber<? super Long> s) {
diff --git a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java
index 9076e2f542..e127334588 100644
--- a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java
@@ -44,7 +44,7 @@ public class OperatorOnErrorResumeNextViaFunctionTest {
     @Test
     public void testResumeNextWithSynchronousExecution() {
         final AtomicReference<Throwable> receivedException = new AtomicReference<Throwable>();
-        Observable<String> w = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> w = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> observer) {
@@ -94,7 +94,7 @@ public Observable<String> call(Throwable t1) {
             }
 
         };
-        Observable<String> observable = Observable.create(w).onErrorResumeNext(resume);
+        Observable<String> observable = Observable.unsafeCreate(w).onErrorResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -131,7 +131,7 @@ public Observable<String> call(Throwable t1) {
             }
 
         };
-        Observable<String> observable = Observable.create(w).onErrorResumeNext(resume);
+        Observable<String> observable = Observable.unsafeCreate(w).onErrorResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
diff --git a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java
index a7315a9158..41f910c2fc 100644
--- a/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java
@@ -42,7 +42,7 @@ public void testResumeNext() {
         Subscription s = mock(Subscription.class);
         // Trigger failure on second element
         TestObservable f = new TestObservable(s, "one", "fail", "two", "three");
-        Observable<String> w = Observable.create(f);
+        Observable<String> w = Observable.unsafeCreate(f);
         Observable<String> resume = Observable.just("twoResume", "threeResume");
         Observable<String> observable = w.onErrorResumeNext(resume);
 
@@ -72,7 +72,7 @@ public void testMapResumeAsyncNext() {
         Observable<String> w = Observable.just("one", "fail", "two", "three", "fail");
         // Resume Observable is async
         TestObservable f = new TestObservable(sr, "twoResume", "threeResume");
-        Observable<String> resume = Observable.create(f);
+        Observable<String> resume = Observable.unsafeCreate(f);
 
         // Introduce map function that fails intermittently (Map does not prevent this when the observer is a
         //  rx.operator incl onErrorResumeNextViaObservable)
@@ -110,7 +110,7 @@ public String call(String s) {
 
     @Test
     public void testResumeNextWithFailedOnSubscribe() {
-        Observable<String> testObservable = Observable.create(new OnSubscribe<String>() {
+        Observable<String> testObservable = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> t1) {
@@ -132,7 +132,7 @@ public void call(Subscriber<? super String> t1) {
 
     @Test
     public void testResumeNextWithFailedOnSubscribeAsync() {
-        Observable<String> testObservable = Observable.create(new OnSubscribe<String>() {
+        Observable<String> testObservable = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> t1) {
diff --git a/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java b/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java
index 57a16e7829..196d5d49ce 100644
--- a/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java
@@ -41,7 +41,7 @@ public class OperatorOnErrorReturnTest {
     @Test
     public void testResumeNext() {
         TestObservable f = new TestObservable("one");
-        Observable<String> w = Observable.create(f);
+        Observable<String> w = Observable.unsafeCreate(f);
         final AtomicReference<Throwable> capturedException = new AtomicReference<Throwable>();
 
         Observable<String> observable = w.onErrorReturn(new Func1<Throwable, String>() {
@@ -77,7 +77,7 @@ public String call(Throwable e) {
     @Test
     public void testFunctionThrowsError() {
         TestObservable f = new TestObservable("one");
-        Observable<String> w = Observable.create(f);
+        Observable<String> w = Observable.unsafeCreate(f);
         final AtomicReference<Throwable> capturedException = new AtomicReference<Throwable>();
 
         Observable<String> observable = w.onErrorReturn(new Func1<Throwable, String>() {
diff --git a/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java b/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java
index 3b403f90e1..b54c7d4c46 100644
--- a/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java
@@ -35,7 +35,7 @@ public class OperatorOnExceptionResumeNextViaObservableTest {
     public void testResumeNextWithException() {
         // Trigger failure on second element
         TestObservable f = new TestObservable("one", "EXCEPTION", "two", "three");
-        Observable<String> w = Observable.create(f);
+        Observable<String> w = Observable.unsafeCreate(f);
         Observable<String> resume = Observable.just("twoResume", "threeResume");
         Observable<String> observable = w.onExceptionResumeNext(resume);
 
@@ -63,7 +63,7 @@ public void testResumeNextWithException() {
     public void testResumeNextWithRuntimeException() {
         // Trigger failure on second element
         TestObservable f = new TestObservable("one", "RUNTIMEEXCEPTION", "two", "three");
-        Observable<String> w = Observable.create(f);
+        Observable<String> w = Observable.unsafeCreate(f);
         Observable<String> resume = Observable.just("twoResume", "threeResume");
         Observable<String> observable = w.onExceptionResumeNext(resume);
 
@@ -91,7 +91,7 @@ public void testResumeNextWithRuntimeException() {
     public void testThrowablePassesThru() {
         // Trigger failure on second element
         TestObservable f = new TestObservable("one", "THROWABLE", "two", "three");
-        Observable<String> w = Observable.create(f);
+        Observable<String> w = Observable.unsafeCreate(f);
         Observable<String> resume = Observable.just("twoResume", "threeResume");
         Observable<String> observable = w.onExceptionResumeNext(resume);
 
@@ -119,7 +119,7 @@ public void testThrowablePassesThru() {
     public void testErrorPassesThru() {
         // Trigger failure on second element
         TestObservable f = new TestObservable("one", "ON_OVERFLOW_ERROR", "two", "three");
-        Observable<String> w = Observable.create(f);
+        Observable<String> w = Observable.unsafeCreate(f);
         Observable<String> resume = Observable.just("twoResume", "threeResume");
         Observable<String> observable = w.onExceptionResumeNext(resume);
 
@@ -149,7 +149,7 @@ public void testMapResumeAsyncNext() {
         Observable<String> w = Observable.just("one", "fail", "two", "three", "fail");
         // Resume Observable is async
         TestObservable f = new TestObservable("twoResume", "threeResume");
-        Observable<String> resume = Observable.create(f);
+        Observable<String> resume = Observable.unsafeCreate(f);
 
         // Introduce map function that fails intermittently (Map does not prevent this when the observer is a
         //  rx.operator incl onErrorResumeNextViaObservable)
diff --git a/src/test/java/rx/internal/operators/OperatorPublishTest.java b/src/test/java/rx/internal/operators/OperatorPublishTest.java
index d0f524159f..9855143447 100644
--- a/src/test/java/rx/internal/operators/OperatorPublishTest.java
+++ b/src/test/java/rx/internal/operators/OperatorPublishTest.java
@@ -37,7 +37,7 @@ public class OperatorPublishTest {
     @Test
     public void testPublish() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        ConnectableObservable<String> o = Observable.create(new OnSubscribe<String>() {
+        ConnectableObservable<String> o = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(final Subscriber<? super String> observer) {
@@ -368,7 +368,7 @@ public void onStart() {
     @Test
     public void testConnectIsIdempotent() {
         final AtomicInteger calls = new AtomicInteger();
-        Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> source = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
                 calls.getAndIncrement();
diff --git a/src/test/java/rx/internal/operators/OperatorRepeatTest.java b/src/test/java/rx/internal/operators/OperatorRepeatTest.java
index c736b2ef3f..1a37f23c05 100644
--- a/src/test/java/rx/internal/operators/OperatorRepeatTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRepeatTest.java
@@ -40,7 +40,7 @@ public class OperatorRepeatTest {
     public void testRepetition() {
         int NUM = 10;
         final AtomicInteger count = new AtomicInteger();
-        int value = Observable.create(new OnSubscribe<Integer>() {
+        int value = Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> o) {
@@ -68,7 +68,7 @@ public void testNoStackOverFlow() {
     public void testRepeatTakeWithSubscribeOn() throws InterruptedException {
 
         final AtomicInteger counter = new AtomicInteger();
-        Observable<Integer> oi = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> oi = Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> sub) {
diff --git a/src/test/java/rx/internal/operators/OperatorReplayTest.java b/src/test/java/rx/internal/operators/OperatorReplayTest.java
index e98c542cd8..e4734c30a6 100644
--- a/src/test/java/rx/internal/operators/OperatorReplayTest.java
+++ b/src/test/java/rx/internal/operators/OperatorReplayTest.java
@@ -915,7 +915,7 @@ public void testColdReplayBackpressure() {
     @Test
     public void testCache() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        Observable<String> o = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> o = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
 
             @Override
             public void call(final Subscriber<? super String> observer) {
@@ -1055,7 +1055,7 @@ public void testNoMissingBackpressureException() {
             m = 4 * 1000 * 1000;
         }
 
-        Observable<Integer> firehose = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> firehose = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
                 for (int i = 0; i < m; i++) {
diff --git a/src/test/java/rx/internal/operators/OperatorRetryTest.java b/src/test/java/rx/internal/operators/OperatorRetryTest.java
index 7937f8945f..d4cf161dc5 100644
--- a/src/test/java/rx/internal/operators/OperatorRetryTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRetryTest.java
@@ -45,7 +45,7 @@ public class OperatorRetryTest {
     public void iterativeBackoff() {
         @SuppressWarnings("unchecked")
         Observer<String> consumer = mock(Observer.class);
-        Observable<String> producer = Observable.create(new OnSubscribe<String>() {
+        Observable<String> producer = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             private AtomicInteger count = new AtomicInteger(4);
             long last = System.currentTimeMillis();
@@ -116,7 +116,7 @@ public void testRetryIndefinitely() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         int NUM_RETRIES = 20;
-        Observable<String> origin = Observable.create(new FuncWithErrors(NUM_RETRIES));
+        Observable<String> origin = Observable.unsafeCreate(new FuncWithErrors(NUM_RETRIES));
         origin.retry().unsafeSubscribe(new TestSubscriber<String>(observer));
 
         InOrder inOrder = inOrder(observer);
@@ -136,7 +136,7 @@ public void testSchedulingNotificationHandler() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         int NUM_RETRIES = 2;
-        Observable<String> origin = Observable.create(new FuncWithErrors(NUM_RETRIES));
+        Observable<String> origin = Observable.unsafeCreate(new FuncWithErrors(NUM_RETRIES));
         TestSubscriber<String> subscriber = new TestSubscriber<String>(observer);
         origin.retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
             @Override
@@ -168,7 +168,7 @@ public void testOnNextFromNotificationHandler() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         int NUM_RETRIES = 2;
-        Observable<String> origin = Observable.create(new FuncWithErrors(NUM_RETRIES));
+        Observable<String> origin = Observable.unsafeCreate(new FuncWithErrors(NUM_RETRIES));
         origin.retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
             @Override
             public Observable<?> call(Observable<? extends Throwable> t1) {
@@ -198,7 +198,7 @@ public Void call(Throwable t1) {
     public void testOnCompletedFromNotificationHandler() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<String> origin = Observable.create(new FuncWithErrors(1));
+        Observable<String> origin = Observable.unsafeCreate(new FuncWithErrors(1));
         TestSubscriber<String> subscriber = new TestSubscriber<String>(observer);
         origin.retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
             @Override
@@ -219,7 +219,7 @@ public Observable<?> call(Observable<? extends Throwable> t1) {
     public void testOnErrorFromNotificationHandler() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<String> origin = Observable.create(new FuncWithErrors(2));
+        Observable<String> origin = Observable.unsafeCreate(new FuncWithErrors(2));
         origin.retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
             @Override
             public Observable<?> call(Observable<? extends Throwable> t1) {
@@ -247,7 +247,7 @@ public void call(Subscriber<? super Integer> subscriber) {
             }
         };
 
-        int first = Observable.create(onSubscribe)
+        int first = Observable.unsafeCreate(onSubscribe)
                 .retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
                     @Override
                     public Observable<?> call(Observable<? extends Throwable> attempt) {
@@ -270,7 +270,7 @@ public Void call(Throwable o, Integer integer) {
     public void testOriginFails() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<String> origin = Observable.create(new FuncWithErrors(1));
+        Observable<String> origin = Observable.unsafeCreate(new FuncWithErrors(1));
         origin.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -286,7 +286,7 @@ public void testRetryFail() {
         int NUM_FAILURES = 2;
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<String> origin = Observable.create(new FuncWithErrors(NUM_FAILURES));
+        Observable<String> origin = Observable.unsafeCreate(new FuncWithErrors(NUM_FAILURES));
         origin.retry(NUM_RETRIES).subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -305,7 +305,7 @@ public void testRetrySuccess() {
         int NUM_FAILURES = 1;
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<String> origin = Observable.create(new FuncWithErrors(NUM_FAILURES));
+        Observable<String> origin = Observable.unsafeCreate(new FuncWithErrors(NUM_FAILURES));
         origin.retry(3).subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -325,7 +325,7 @@ public void testInfiniteRetry() {
         int NUM_FAILURES = 20;
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<String> origin = Observable.create(new FuncWithErrors(NUM_FAILURES));
+        Observable<String> origin = Observable.unsafeCreate(new FuncWithErrors(NUM_FAILURES));
         origin.retry().subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -478,7 +478,7 @@ public boolean isUnsubscribed() {
                 });
             }
         };
-        Observable<String> stream = Observable.create(onSubscribe);
+        Observable<String> stream = Observable.unsafeCreate(onSubscribe);
         Observable<String> streamWithRetry = stream.retry();
         Subscription sub = streamWithRetry.subscribe();
         assertEquals(1, subsCount.get());
@@ -512,7 +512,7 @@ public void call(Subscriber<? super String> s) {
             }
         };
 
-        Observable.create(onSubscribe).retry(3).subscribe(ts);
+        Observable.unsafeCreate(onSubscribe).retry(3).subscribe(ts);
         assertEquals(4, subsCount.get()); // 1 + 3 retries
     }
 
@@ -530,7 +530,7 @@ public void call(Subscriber<? super String> s) {
             }
         };
 
-        Observable.create(onSubscribe).retry(1).subscribe(ts);
+        Observable.unsafeCreate(onSubscribe).retry(1).subscribe(ts);
         assertEquals(2, subsCount.get());
     }
 
@@ -548,7 +548,7 @@ public void call(Subscriber<? super String> s) {
             }
         };
 
-        Observable.create(onSubscribe).retry(0).subscribe(ts);
+        Observable.unsafeCreate(onSubscribe).retry(0).subscribe(ts);
         assertEquals(1, subsCount.get());
     }
 
@@ -651,7 +651,7 @@ public void testUnsubscribeAfterError() {
 
         // Observable that always fails after 100ms
         SlowObservable so = new SlowObservable(100, 0);
-        Observable<Long> o = Observable.create(so).retry(5);
+        Observable<Long> o = Observable.unsafeCreate(so).retry(5);
 
         AsyncObserver<Long> async = new AsyncObserver<Long>(observer);
 
@@ -676,7 +676,7 @@ public void testTimeoutWithRetry() {
 
         // Observable that sends every 100ms (timeout fails instead)
         SlowObservable so = new SlowObservable(100, 10);
-        Observable<Long> o = Observable.create(so).timeout(80, TimeUnit.MILLISECONDS).retry(5);
+        Observable<Long> o = Observable.unsafeCreate(so).timeout(80, TimeUnit.MILLISECONDS).retry(5);
 
         AsyncObserver<Long> async = new AsyncObserver<Long>(observer);
 
@@ -700,7 +700,7 @@ public void testRetryWithBackpressure() throws InterruptedException {
             for (int i = 0; i < 400; i++) {
                 @SuppressWarnings("unchecked")
                 Observer<String> observer = mock(Observer.class);
-                Observable<String> origin = Observable.create(new FuncWithErrors(NUM_RETRIES));
+                Observable<String> origin = Observable.unsafeCreate(new FuncWithErrors(NUM_RETRIES));
                 TestSubscriber<String> ts = new TestSubscriber<String>(observer);
                 origin.retry().observeOn(Schedulers.computation()).unsafeSubscribe(ts);
                 ts.awaitTerminalEvent(5, TimeUnit.SECONDS);
@@ -743,7 +743,7 @@ public void testRetryWithBackpressureParallel() throws InterruptedException {
                         public void run() {
                             final AtomicInteger nexts = new AtomicInteger();
                             try {
-                                Observable<String> origin = Observable.create(new FuncWithErrors(NUM_RETRIES));
+                                Observable<String> origin = Observable.unsafeCreate(new FuncWithErrors(NUM_RETRIES));
                                 TestSubscriber<String> ts = new TestSubscriber<String>();
                                 origin.retry()
                                 .observeOn(Schedulers.computation()).unsafeSubscribe(ts);
@@ -866,7 +866,7 @@ public void testIssue1900SourceNotSupportingBackpressure() {
         final int NUM_MSG = 1034;
         final AtomicInteger count = new AtomicInteger();
 
-        Observable<String> origin = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> origin = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> o) {
diff --git a/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java b/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java
index f526d327f6..dab59e9f0d 100644
--- a/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java
+++ b/src/test/java/rx/internal/operators/OperatorRetryWithPredicateTest.java
@@ -81,7 +81,7 @@ public void testWithNothingToRetry() {
     }
     @Test
     public void testRetryTwice() {
-        Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> source = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             int count;
             @Override
             public void call(Subscriber<? super Integer> t1) {
@@ -116,7 +116,7 @@ public void call(Subscriber<? super Integer> t1) {
     }
     @Test
     public void testRetryTwiceAndGiveUp() {
-        Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> source = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t1) {
                 t1.onNext(0);
@@ -143,7 +143,7 @@ public void call(Subscriber<? super Integer> t1) {
     }
     @Test
     public void testRetryOnSpecificException() {
-        Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> source = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             int count;
             @Override
             public void call(Subscriber<? super Integer> t1) {
@@ -179,7 +179,7 @@ public void call(Subscriber<? super Integer> t1) {
     public void testRetryOnSpecificExceptionAndNotOther() {
         final IOException ioe = new IOException();
         final TestException te = new TestException();
-        Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> source = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             int count;
             @Override
             public void call(Subscriber<? super Integer> t1) {
@@ -238,7 +238,7 @@ public void testUnsubscribeAfterError() {
         // Observable that always fails after 100ms
         OperatorRetryTest.SlowObservable so = new OperatorRetryTest.SlowObservable(100, 0);
         Observable<Long> o = Observable
-                .create(so)
+                .unsafeCreate(so)
                 .retry(retry5);
 
         OperatorRetryTest.AsyncObserver<Long> async = new OperatorRetryTest.AsyncObserver<Long>(observer);
@@ -265,7 +265,7 @@ public void testTimeoutWithRetry() {
         // Observable that sends every 100ms (timeout fails instead)
         OperatorRetryTest.SlowObservable so = new OperatorRetryTest.SlowObservable(100, 10);
         Observable<Long> o = Observable
-                .create(so)
+                .unsafeCreate(so)
                 .timeout(80, TimeUnit.MILLISECONDS)
                 .retry(retry5);
 
diff --git a/src/test/java/rx/internal/operators/OperatorSampleTest.java b/src/test/java/rx/internal/operators/OperatorSampleTest.java
index 04000973ec..20d59d8523 100644
--- a/src/test/java/rx/internal/operators/OperatorSampleTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSampleTest.java
@@ -50,7 +50,7 @@ public void before() {
 
     @Test
     public void testSample() {
-        Observable<Long> source = Observable.create(new OnSubscribe<Long>() {
+        Observable<Long> source = Observable.unsafeCreate(new OnSubscribe<Long>() {
             @Override
             public void call(final Subscriber<? super Long> observer1) {
                 innerScheduler.schedule(new Action0() {
@@ -111,7 +111,7 @@ public void call() {
 
     @Test
     public void sampleWithTimeEmitAndTerminate() {
-        Observable<Long> source = Observable.create(new OnSubscribe<Long>() {
+        Observable<Long> source = Observable.unsafeCreate(new OnSubscribe<Long>() {
             @Override
             public void call(final Subscriber<? super Long> observer1) {
                 innerScheduler.schedule(new Action0() {
@@ -303,7 +303,7 @@ public void sampleWithSamplerThrows() {
     @Test
     public void testSampleUnsubscribe() {
         final Subscription s = mock(Subscription.class);
-        Observable<Integer> o = Observable.create(
+        Observable<Integer> o = Observable.unsafeCreate(
                 new OnSubscribe<Integer>() {
                     @Override
                     public void call(Subscriber<? super Integer> subscriber) {
@@ -387,7 +387,7 @@ public void dontUnsubscribeChild2() {
 
     @Test
     public void neverSetProducer() {
-        Observable<Integer> neverBackpressure = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> neverBackpressure = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
                 t.setProducer(new Producer() {
@@ -430,7 +430,7 @@ public void setProducer(Producer p) {
     public void unsubscribeMainAfterCompleted() {
         final AtomicBoolean unsubscribed = new AtomicBoolean();
 
-        Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> source = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
                 t.add(Subscriptions.create(new Action0() {
@@ -467,7 +467,7 @@ public void onCompleted() {
     public void unsubscribeSamplerAfterCompleted() {
         final AtomicBoolean unsubscribed = new AtomicBoolean();
 
-        Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> source = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
                 t.add(Subscriptions.create(new Action0() {
diff --git a/src/test/java/rx/internal/operators/OperatorScanTest.java b/src/test/java/rx/internal/operators/OperatorScanTest.java
index c6bf08b718..e20519ed17 100644
--- a/src/test/java/rx/internal/operators/OperatorScanTest.java
+++ b/src/test/java/rx/internal/operators/OperatorScanTest.java
@@ -306,7 +306,7 @@ public Integer call(Integer t1, Integer t2) {
     @Test
     public void testScanShouldNotRequestZero() {
         final AtomicReference<Producer> producer = new AtomicReference<Producer>();
-        Observable<Integer> o = Observable.create(new Observable.OnSubscribe<Integer>() {
+        Observable<Integer> o = Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
             @Override
             public void call(final Subscriber<? super Integer> subscriber) {
                 Producer p = spy(new Producer() {
@@ -371,7 +371,7 @@ public Integer call(Integer t1, Integer t2) {
 
     @Test
     public void testInitialValueEmittedWithProducer() {
-        Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> source = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> t) {
                 t.setProducer(new Producer() {
diff --git a/src/test/java/rx/internal/operators/OperatorSerializeTest.java b/src/test/java/rx/internal/operators/OperatorSerializeTest.java
index 450e2e0185..14d38dd76b 100644
--- a/src/test/java/rx/internal/operators/OperatorSerializeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSerializeTest.java
@@ -51,7 +51,7 @@ public void before() {
     @Test
     public void testSingleThreadedBasic() {
         TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable("one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
+        Observable<String> w = Observable.unsafeCreate(onSubscribe);
 
         w.serialize().subscribe(observer);
         onSubscribe.waitToFinish();
@@ -69,7 +69,7 @@ public void testSingleThreadedBasic() {
     @Test
     public void testMultiThreadedBasic() {
         TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
+        Observable<String> w = Observable.unsafeCreate(onSubscribe);
 
         BusyObserver busyobserver = new BusyObserver();
 
@@ -92,7 +92,7 @@ public void testMultiThreadedBasic() {
     @Test
     public void testMultiThreadedWithNPE() {
         TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null);
-        Observable<String> w = Observable.create(onSubscribe);
+        Observable<String> w = Observable.unsafeCreate(onSubscribe);
 
         BusyObserver busyobserver = new BusyObserver();
 
@@ -123,7 +123,7 @@ public void testMultiThreadedWithNPEinMiddle() {
         boolean lessThan9 = false;
         for (int i = 0; i < 3; i++) {
             TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
-            Observable<String> w = Observable.create(onSubscribe);
+            Observable<String> w = Observable.unsafeCreate(onSubscribe);
 
             BusyObserver busyobserver = new BusyObserver();
 
diff --git a/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java b/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
index 65f1b9870e..6eb4abd8e8 100644
--- a/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
@@ -50,7 +50,7 @@ public void testIssue813() throws InterruptedException {
         TestSubscriber<Integer> observer = new TestSubscriber<Integer>();
 
         final Subscription subscription = Observable
-                .create(new Observable.OnSubscribe<Integer>() {
+                .unsafeCreate(new Observable.OnSubscribe<Integer>() {
                     @Override
                     public void call(
                             final Subscriber<? super Integer> subscriber) {
@@ -85,7 +85,7 @@ public void call(
     @Test
     public void testThrownErrorHandling() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
-        Observable.create(new OnSubscribe<String>() {
+        Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> s) {
@@ -100,7 +100,7 @@ public void call(Subscriber<? super String> s) {
     @Test
     public void testOnError() {
         TestSubscriber<String> ts = new TestSubscriber<String>();
-        Observable.create(new OnSubscribe<String>() {
+        Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> s) {
@@ -170,7 +170,7 @@ public Subscription schedule(final Action0 action, final long delayTime, final T
     public void testUnsubscribeInfiniteStream() throws InterruptedException {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         final AtomicInteger count = new AtomicInteger();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> sub) {
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java b/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
index 70225a53eb..5108f4001d 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
@@ -58,7 +58,7 @@ public void testSwitchWhenEmpty() throws Exception {
     @Test
     public void testSwitchWithProducer() throws Exception {
         final AtomicBoolean emitted = new AtomicBoolean(false);
-        Observable<Long> withProducer = Observable.create(new Observable.OnSubscribe<Long>() {
+        Observable<Long> withProducer = Observable.unsafeCreate(new Observable.OnSubscribe<Long>() {
             @Override
             public void call(final Subscriber<? super Long> subscriber) {
                 subscriber.setProducer(new Producer() {
@@ -82,7 +82,7 @@ public void request(long n) {
     public void testSwitchTriggerUnsubscribe() throws Exception {
         final Subscription empty = Subscriptions.empty();
 
-        Observable<Long> withProducer = Observable.create(new Observable.OnSubscribe<Long>() {
+        Observable<Long> withProducer = Observable.unsafeCreate(new Observable.OnSubscribe<Long>() {
             @Override
             public void call(final Subscriber<? super Long> subscriber) {
                 subscriber.add(empty);
@@ -121,7 +121,7 @@ public void onNext(Long aLong) {
     public void testSwitchShouldTriggerUnsubscribe() {
         final Subscription s = Subscriptions.empty();
 
-        Observable.create(new Observable.OnSubscribe<Long>() {
+        Observable.unsafeCreate(new Observable.OnSubscribe<Long>() {
             @Override
             public void call(final Subscriber<? super Long> subscriber) {
                 subscriber.add(s);
@@ -176,7 +176,7 @@ public void testBackpressureOnFirstObservable() {
     @Test(timeout = 10000)
     public void testRequestsNotLost() throws InterruptedException {
         final TestSubscriber<Long> ts = new TestSubscriber<Long>(0);
-        Observable.create(new OnSubscribe<Long>() {
+        Observable.unsafeCreate(new OnSubscribe<Long>() {
 
             @Override
             public void call(final Subscriber<? super Long> subscriber) {
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchTest.java b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
index 1a8732e341..8525c18cd6 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
@@ -53,10 +53,10 @@ public void before() {
 
     @Test
     public void testSwitchWhenOuterCompleteBeforeInner() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
-                publishNext(observer, 50, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 50, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 70, "one");
@@ -80,10 +80,10 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testSwitchWhenInnerCompleteBeforeOuter() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
-                publishNext(observer, 10, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 10, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 0, "one");
@@ -92,7 +92,7 @@ public void call(Subscriber<? super String> observer) {
                     }
                 }));
 
-                publishNext(observer, 100, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 100, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 0, "three");
@@ -123,10 +123,10 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testSwitchWithComplete() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
-                publishNext(observer, 50, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 50, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(final Subscriber<? super String> observer) {
                         publishNext(observer, 60, "one");
@@ -134,7 +134,7 @@ public void call(final Subscriber<? super String> observer) {
                     }
                 }));
 
-                publishNext(observer, 200, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 200, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(final Subscriber<? super String> observer) {
                         publishNext(observer, 0, "three");
@@ -179,10 +179,10 @@ public void call(final Subscriber<? super String> observer) {
 
     @Test
     public void testSwitchWithError() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
-                publishNext(observer, 50, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 50, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(final Subscriber<? super String> observer) {
                         publishNext(observer, 50, "one");
@@ -190,7 +190,7 @@ public void call(final Subscriber<? super String> observer) {
                     }
                 }));
 
-                publishNext(observer, 200, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 200, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 0, "three");
@@ -235,10 +235,10 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testSwitchWithSubsequenceComplete() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
-                publishNext(observer, 50, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 50, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 50, "one");
@@ -246,14 +246,14 @@ public void call(Subscriber<? super String> observer) {
                     }
                 }));
 
-                publishNext(observer, 130, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 130, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishCompleted(observer, 0);
                     }
                 }));
 
-                publishNext(observer, 150, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 150, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 50, "three");
@@ -285,10 +285,10 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testSwitchWithSubsequenceError() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
-                publishNext(observer, 50, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 50, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 50, "one");
@@ -296,14 +296,14 @@ public void call(Subscriber<? super String> observer) {
                     }
                 }));
 
-                publishNext(observer, 130, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 130, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishError(observer, 0, new TestException());
                     }
                 }));
 
-                publishNext(observer, 150, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 150, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 50, "three");
@@ -364,10 +364,10 @@ public void call() {
     @Test
     public void testSwitchIssue737() {
         // https://github.com/ReactiveX/RxJava/issues/737
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
-                publishNext(observer, 0, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 0, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 10, "1-one");
@@ -377,7 +377,7 @@ public void call(Subscriber<? super String> observer) {
                         publishCompleted(observer, 40);
                     }
                 }));
-                publishNext(observer, 25, Observable.create(new Observable.OnSubscribe<String>() {
+                publishNext(observer, 25, Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
                     @Override
                     public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 10, "2-one");
@@ -407,7 +407,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testBackpressure() {
-        final Observable<String> o1 = Observable.create(new Observable.OnSubscribe<String>() {
+        final Observable<String> o1 = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(final Subscriber<? super String> observer) {
                 observer.setProducer(new Producer() {
@@ -428,7 +428,7 @@ public void request(long n) {
                 });
             }
         });
-        final Observable<String> o2 = Observable.create(new Observable.OnSubscribe<String>() {
+        final Observable<String> o2 = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(final Subscriber<? super String> observer) {
                 observer.setProducer(new Producer() {
@@ -449,7 +449,7 @@ public void request(long n) {
                 });
             }
         });
-        final Observable<String> o3 = Observable.create(new Observable.OnSubscribe<String>() {
+        final Observable<String> o3 = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(final Subscriber<? super String> observer) {
                 observer.setProducer(new Producer() {
@@ -469,7 +469,7 @@ public void request(long n) {
                 });
             }
         });
-        Observable<Observable<String>> o = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
+        Observable<Observable<String>> o = Observable.unsafeCreate(new Observable.OnSubscribe<Observable<String>>() {
             @Override
             public void call(Subscriber<? super Observable<String>> observer) {
                 publishNext(observer, 10, o1);
@@ -519,7 +519,7 @@ public void onNext(String s) {
     public void testUnsubscribe() {
         final AtomicBoolean isUnsubscribed = new AtomicBoolean();
         Observable.switchOnNext(
-                Observable.create(new Observable.OnSubscribe<Observable<Integer>>() {
+                Observable.unsafeCreate(new Observable.OnSubscribe<Observable<Integer>>() {
                     @Override
                     public void call(final Subscriber<? super Observable<Integer>> subscriber) {
                         subscriber.onNext(Observable.just(1));
diff --git a/src/test/java/rx/internal/operators/OperatorTakeTest.java b/src/test/java/rx/internal/operators/OperatorTakeTest.java
index 0dc3dbc8c4..edf17bac10 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeTest.java
@@ -112,7 +112,7 @@ public Integer call(Integer t1) {
 
     @Test
     public void testTakeDoesntLeakErrors() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
@@ -136,7 +136,7 @@ public void call(Subscriber<? super String> observer) {
     public void testTakeZeroDoesntLeakError() {
         final AtomicBoolean subscribed = new AtomicBoolean(false);
         final AtomicBoolean unSubscribed = new AtomicBoolean(false);
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 subscribed.set(true);
@@ -173,7 +173,7 @@ public boolean isUnsubscribed() {
     public void testUnsubscribeAfterTake() {
         final Subscription s = mock(Subscription.class);
         TestObservableFunc f = new TestObservableFunc("one", "two", "three");
-        Observable<String> w = Observable.create(f);
+        Observable<String> w = Observable.unsafeCreate(f);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -218,7 +218,7 @@ public void call(Long l) {
     @Test(timeout = 2000)
     public void testMultiTake() {
         final AtomicInteger count = new AtomicInteger();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -277,7 +277,7 @@ public void run() {
         }
     }
 
-    private static Observable<Long> INFINITE_OBSERVABLE = Observable.create(new OnSubscribe<Long>() {
+    private static Observable<Long> INFINITE_OBSERVABLE = Observable.unsafeCreate(new OnSubscribe<Long>() {
 
         @Override
         public void call(Subscriber<? super Long> op) {
@@ -311,7 +311,7 @@ public void testProducerRequestThroughTake() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         ts.requestMore(3);
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
@@ -334,7 +334,7 @@ public void testProducerRequestThroughTakeIsModified() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         ts.requestMore(3);
         final AtomicLong requested = new AtomicLong();
-        Observable.create(new OnSubscribe<Integer>() {
+        Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(Subscriber<? super Integer> s) {
diff --git a/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java b/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
index 28c0c432ff..5c590c68c5 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeUntilTest.java
@@ -40,7 +40,7 @@ public void testTakeUntil() {
         TestObservable other = new TestObservable(sOther);
 
         Observer<String> result = mock(Observer.class);
-        Observable<String> stringObservable = Observable.create(source).takeUntil(Observable.create(other));
+        Observable<String> stringObservable = Observable.unsafeCreate(source).takeUntil(Observable.unsafeCreate(other));
         stringObservable.subscribe(result);
         source.sendOnNext("one");
         source.sendOnNext("two");
@@ -67,7 +67,7 @@ public void testTakeUntilSourceCompleted() {
         TestObservable other = new TestObservable(sOther);
 
         Observer<String> result = mock(Observer.class);
-        Observable<String> stringObservable = Observable.create(source).takeUntil(Observable.create(other));
+        Observable<String> stringObservable = Observable.unsafeCreate(source).takeUntil(Observable.unsafeCreate(other));
         stringObservable.subscribe(result);
         source.sendOnNext("one");
         source.sendOnNext("two");
@@ -90,7 +90,7 @@ public void testTakeUntilSourceError() {
         Throwable error = new Throwable();
 
         Observer<String> result = mock(Observer.class);
-        Observable<String> stringObservable = Observable.create(source).takeUntil(Observable.create(other));
+        Observable<String> stringObservable = Observable.unsafeCreate(source).takeUntil(Observable.unsafeCreate(other));
         stringObservable.subscribe(result);
         source.sendOnNext("one");
         source.sendOnNext("two");
@@ -116,7 +116,7 @@ public void testTakeUntilOtherError() {
         Throwable error = new Throwable();
 
         Observer<String> result = mock(Observer.class);
-        Observable<String> stringObservable = Observable.create(source).takeUntil(Observable.create(other));
+        Observable<String> stringObservable = Observable.unsafeCreate(source).takeUntil(Observable.unsafeCreate(other));
         stringObservable.subscribe(result);
         source.sendOnNext("one");
         source.sendOnNext("two");
@@ -145,7 +145,7 @@ public void testTakeUntilOtherCompleted() {
         TestObservable other = new TestObservable(sOther);
 
         Observer<String> result = mock(Observer.class);
-        Observable<String> stringObservable = Observable.create(source).takeUntil(Observable.create(other));
+        Observable<String> stringObservable = Observable.unsafeCreate(source).takeUntil(Observable.unsafeCreate(other));
         stringObservable.subscribe(result);
         source.sendOnNext("one");
         source.sendOnNext("two");
diff --git a/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java b/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java
index 0a3cd3ec94..2537e0e807 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeWhileTest.java
@@ -107,7 +107,7 @@ public Boolean call(String input) {
 
     @Test
     public void testTakeWhileDoesntLeakErrors() {
-        Observable<String> source = Observable.create(new OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
@@ -130,7 +130,7 @@ public void testTakeWhileProtectsPredicateCall() {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<String> take = Observable.create(source).takeWhile(new Func1<String, Boolean>() {
+        Observable<String> take = Observable.unsafeCreate(source).takeWhile(new Func1<String, Boolean>() {
             @Override
             public Boolean call(String s) {
                 throw testException;
@@ -157,7 +157,7 @@ public void testUnsubscribeAfterTake() {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<String> take = Observable.create(w).takeWhile(new Func1<String, Boolean>() {
+        Observable<String> take = Observable.unsafeCreate(w).takeWhile(new Func1<String, Boolean>() {
             int index;
 
             @Override
diff --git a/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java b/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
index f608cb22c6..4908efc534 100644
--- a/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
+++ b/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
@@ -55,7 +55,7 @@ public void before() {
 
     @Test
     public void testThrottlingWithCompleted() {
-        Observable<String> source = Observable.create(new OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 publishNext(observer, 100, "one");    // publish as it's first
@@ -82,7 +82,7 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testThrottlingWithError() {
-        Observable<String> source = Observable.create(new OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 Exception error = new TestException();
diff --git a/src/test/java/rx/internal/operators/OperatorTimeoutTests.java b/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
index 3071d78f6d..fba5b1d6c5 100644
--- a/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
+++ b/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
@@ -234,7 +234,7 @@ public void shouldTimeoutIfSynchronizedObservableEmitFirstOnNextNotWithinTimeout
 
             @Override
             public void run() {
-                Observable.create(new OnSubscribe<String>() {
+                Observable.unsafeCreate(new OnSubscribe<String>() {
 
                     @Override
                     public void call(Subscriber<? super String> subscriber) {
@@ -268,7 +268,7 @@ public void shouldUnsubscribeFromUnderlyingSubscriptionOnTimeout() throws Interr
         // From https://github.com/ReactiveX/RxJava/pull/951
         final Subscription s = mock(Subscription.class);
 
-        Observable<String> never = Observable.create(new OnSubscribe<String>() {
+        Observable<String> never = Observable.unsafeCreate(new OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> subscriber) {
                 subscriber.add(s);
@@ -296,7 +296,7 @@ public void shouldUnsubscribeFromUnderlyingSubscriptionOnImmediatelyComplete() {
         // From https://github.com/ReactiveX/RxJava/pull/951
         final Subscription s = mock(Subscription.class);
 
-        Observable<String> immediatelyComplete = Observable.create(new OnSubscribe<String>() {
+        Observable<String> immediatelyComplete = Observable.unsafeCreate(new OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> subscriber) {
                 subscriber.add(s);
@@ -326,7 +326,7 @@ public void shouldUnsubscribeFromUnderlyingSubscriptionOnImmediatelyErrored() th
         // From https://github.com/ReactiveX/RxJava/pull/951
         final Subscription s = mock(Subscription.class);
 
-        Observable<String> immediatelyError = Observable.create(new OnSubscribe<String>() {
+        Observable<String> immediatelyError = Observable.unsafeCreate(new OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> subscriber) {
                 subscriber.add(s);
diff --git a/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java b/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
index d2d0e2e567..50ce9e5865 100644
--- a/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
@@ -334,7 +334,7 @@ public void testTimeoutSelectorWithTimeoutAndOnNextRaceCondition() throws Interr
             public Observable<Integer> call(Integer t1) {
                 if (t1 == 1) {
                     // Force "unsubscribe" run on another thread
-                    return Observable.create(new OnSubscribe<Integer>() {
+                    return Observable.unsafeCreate(new OnSubscribe<Integer>() {
                         @Override
                         public void call(Subscriber<? super Integer> subscriber) {
                             enteredTimeoutOne.countDown();
diff --git a/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java b/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
index 8e4317af40..fe8d664122 100644
--- a/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
@@ -39,7 +39,7 @@ public void testUnsubscribeWhenSubscribeOnAndUnsubscribeOnAreOnSameThread() thro
         try {
             final ThreadSubscription subscription = new ThreadSubscription();
             final AtomicReference<Thread> subscribeThread = new AtomicReference<Thread>();
-            Observable<Integer> w = Observable.create(new OnSubscribe<Integer>() {
+            Observable<Integer> w = Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
                 @Override
                 public void call(Subscriber<? super Integer> t1) {
@@ -84,7 +84,7 @@ public void testUnsubscribeWhenSubscribeOnAndUnsubscribeOnAreOnDifferentThreads(
         try {
             final ThreadSubscription subscription = new ThreadSubscription();
             final AtomicReference<Thread> subscribeThread = new AtomicReference<Thread>();
-            Observable<Integer> w = Observable.create(new OnSubscribe<Integer>() {
+            Observable<Integer> w = Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
                 @Override
                 public void call(Subscriber<? super Integer> t1) {
diff --git a/src/test/java/rx/internal/operators/OperatorWindowWithSizeTest.java b/src/test/java/rx/internal/operators/OperatorWindowWithSizeTest.java
index 7f74cd1ee0..2e9b718e67 100644
--- a/src/test/java/rx/internal/operators/OperatorWindowWithSizeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorWindowWithSizeTest.java
@@ -249,7 +249,7 @@ public void onCompleted() {
     }
 
     public static Observable<Integer> hotStream() {
-        return Observable.create(new OnSubscribe<Integer>() {
+        return Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> s) {
                 while (!s.isUnsubscribed()) {
diff --git a/src/test/java/rx/internal/operators/OperatorWindowWithStartEndObservableTest.java b/src/test/java/rx/internal/operators/OperatorWindowWithStartEndObservableTest.java
index 858465a877..eeb47b89be 100644
--- a/src/test/java/rx/internal/operators/OperatorWindowWithStartEndObservableTest.java
+++ b/src/test/java/rx/internal/operators/OperatorWindowWithStartEndObservableTest.java
@@ -46,7 +46,7 @@ public void testObservableBasedOpenerAndCloser() {
         final List<String> list = new ArrayList<String>();
         final List<List<String>> lists = new ArrayList<List<String>>();
 
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
@@ -58,7 +58,7 @@ public void call(Subscriber<? super String> observer) {
             }
         });
 
-        Observable<Object> openings = Observable.create(new Observable.OnSubscribe<Object>() {
+        Observable<Object> openings = Observable.unsafeCreate(new Observable.OnSubscribe<Object>() {
             @Override
             public void call(Subscriber<? super Object> observer) {
                 push(observer, new Object(), 50);
@@ -70,7 +70,7 @@ public void call(Subscriber<? super Object> observer) {
         Func1<Object, Observable<Object>> closer = new Func1<Object, Observable<Object>>() {
             @Override
             public Observable<Object> call(Object opening) {
-                return Observable.create(new Observable.OnSubscribe<Object>() {
+                return Observable.unsafeCreate(new Observable.OnSubscribe<Object>() {
                     @Override
                     public void call(Subscriber<? super Object> observer) {
                         push(observer, new Object(), 100);
@@ -94,7 +94,7 @@ public void testObservableBasedCloser() {
         final List<String> list = new ArrayList<String>();
         final List<List<String>> lists = new ArrayList<List<String>>();
 
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
@@ -110,7 +110,7 @@ public void call(Subscriber<? super String> observer) {
             int calls;
             @Override
             public Observable<Object> call() {
-                return Observable.create(new Observable.OnSubscribe<Object>() {
+                return Observable.unsafeCreate(new Observable.OnSubscribe<Object>() {
                     @Override
                     public void call(Subscriber<? super Object> observer) {
                         int c = calls++;
diff --git a/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java b/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java
index 71a59ff510..78500db578 100644
--- a/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorWindowWithTimeTest.java
@@ -45,7 +45,7 @@ public void testTimedAndCount() {
         final List<String> list = new ArrayList<String>();
         final List<List<String>> lists = new ArrayList<List<String>>();
 
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
@@ -78,7 +78,7 @@ public void testTimed() {
         final List<String> list = new ArrayList<String>();
         final List<List<String>> lists = new ArrayList<List<String>>();
 
-        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
+        Observable<String> source = Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 98);
diff --git a/src/test/java/rx/internal/operators/OperatorZipTest.java b/src/test/java/rx/internal/operators/OperatorZipTest.java
index 908f44a23d..5f4b06bcbe 100644
--- a/src/test/java/rx/internal/operators/OperatorZipTest.java
+++ b/src/test/java/rx/internal/operators/OperatorZipTest.java
@@ -94,7 +94,7 @@ public void testStartpingDifferentLengthObservableSequences1() {
         TestObservable w2 = new TestObservable();
         TestObservable w3 = new TestObservable();
 
-        Observable<String> zipW = Observable.zip(Observable.create(w1), Observable.create(w2), Observable.create(w3), getConcat3StringsZipr());
+        Observable<String> zipW = Observable.zip(Observable.unsafeCreate(w1), Observable.unsafeCreate(w2), Observable.unsafeCreate(w3), getConcat3StringsZipr());
         zipW.subscribe(w);
 
         /* simulate sending data */
@@ -128,7 +128,7 @@ public void testStartpingDifferentLengthObservableSequences2() {
         TestObservable w2 = new TestObservable();
         TestObservable w3 = new TestObservable();
 
-        Observable<String> zipW = Observable.zip(Observable.create(w1), Observable.create(w2), Observable.create(w3), getConcat3StringsZipr());
+        Observable<String> zipW = Observable.zip(Observable.unsafeCreate(w1), Observable.unsafeCreate(w2), Observable.unsafeCreate(w3), getConcat3StringsZipr());
         zipW.subscribe(w);
 
         /* simulate sending data */
@@ -1212,7 +1212,7 @@ public boolean hasNext() {
     Observable<Integer> OBSERVABLE_OF_5_INTEGERS = OBSERVABLE_OF_5_INTEGERS(new AtomicInteger());
 
     Observable<Integer> OBSERVABLE_OF_5_INTEGERS(final AtomicInteger numEmitted) {
-        return Observable.create(new OnSubscribe<Integer>() {
+        return Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> o) {
@@ -1231,7 +1231,7 @@ public void call(final Subscriber<? super Integer> o) {
     }
 
     Observable<Integer> ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(final CountDownLatch latch) {
-        return Observable.create(new OnSubscribe<Integer>() {
+        return Observable.unsafeCreate(new OnSubscribe<Integer>() {
 
             @Override
             public void call(final Subscriber<? super Integer> o) {
diff --git a/src/test/java/rx/internal/operators/SafeSubscriberTest.java b/src/test/java/rx/internal/operators/SafeSubscriberTest.java
index cf71a8f5d1..57fc3446bc 100644
--- a/src/test/java/rx/internal/operators/SafeSubscriberTest.java
+++ b/src/test/java/rx/internal/operators/SafeSubscriberTest.java
@@ -38,7 +38,7 @@ public class SafeSubscriberTest {
     @Test
     public void testOnNextAfterOnError() {
         TestObservable t = new TestObservable();
-        Observable<String> st = Observable.create(t);
+        Observable<String> st = Observable.unsafeCreate(t);
 
         @SuppressWarnings("unchecked")
         Observer<String> w = mock(Observer.class);
@@ -60,7 +60,7 @@ public void testOnNextAfterOnError() {
     @Test
     public void testOnCompletedAfterOnError() {
         TestObservable t = new TestObservable();
-        Observable<String> st = Observable.create(t);
+        Observable<String> st = Observable.unsafeCreate(t);
 
         @SuppressWarnings("unchecked")
         Observer<String> w = mock(Observer.class);
@@ -82,7 +82,7 @@ public void testOnCompletedAfterOnError() {
     @Test
     public void testOnNextAfterOnCompleted() {
         TestObservable t = new TestObservable();
-        Observable<String> st = Observable.create(t);
+        Observable<String> st = Observable.unsafeCreate(t);
 
         @SuppressWarnings("unchecked")
         Observer<String> w = mock(Observer.class);
@@ -105,7 +105,7 @@ public void testOnNextAfterOnCompleted() {
     @Test
     public void testOnErrorAfterOnCompleted() {
         TestObservable t = new TestObservable();
-        Observable<String> st = Observable.create(t);
+        Observable<String> st = Observable.unsafeCreate(t);
 
         @SuppressWarnings("unchecked")
         Observer<String> w = mock(Observer.class);
diff --git a/src/test/java/rx/internal/producers/ProducersTest.java b/src/test/java/rx/internal/producers/ProducersTest.java
index f41fcda71a..46533b8ada 100644
--- a/src/test/java/rx/internal/producers/ProducersTest.java
+++ b/src/test/java/rx/internal/producers/ProducersTest.java
@@ -365,7 +365,7 @@ public void testObserverArbiterAsync() {
                 .map(plus(40))
         );
 
-        Observable<Long> source = Observable.create(
+        Observable<Long> source = Observable.unsafeCreate(
             new SwitchTimer<Long>(timers, 550,
             TimeUnit.MILLISECONDS, test));
 
diff --git a/src/test/java/rx/observables/AsyncOnSubscribeTest.java b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
index a711d92c91..d344532aae 100644
--- a/src/test/java/rx/observables/AsyncOnSubscribeTest.java
+++ b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
@@ -110,7 +110,7 @@ public void testSubscribedByBufferingOperator() {
             public void call(Long requested, Observer<Observable<? extends Integer>> observer) {
                 observer.onNext(Observable.range(1, requested.intValue()));
             }});
-        Observable.create(os).observeOn(scheduler).subscribe(subscriber);
+        Observable.unsafeCreate(os).observeOn(scheduler).subscribe(subscriber);
         subscriber.requestMore(RxRingBuffer.SIZE);
         scheduler.advanceTimeBy(10, TimeUnit.DAYS);
         subscriber.assertNoErrors();
@@ -141,7 +141,7 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
             public void call(Integer t) {
                 lastState.set(t);
             }});
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
         subscriber.requestMore(1); // [[1]], state = 1
         subscriber.requestMore(2); // [[1]], state = 2
         subscriber.requestMore(3); // onComplete, state = 3
@@ -158,7 +158,7 @@ public void testOnCompleteOuter() throws InterruptedException {
             public void call(Long requested, Observer<Observable<? extends Integer>> observer) {
                 observer.onCompleted();
             }});
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
         subscriber.requestMore(1);
         subscriber.assertNoErrors();
         subscriber.assertCompleted();
@@ -174,7 +174,7 @@ public void call(Long requested, Observer<Observable<? extends Integer>> observe
                 observer.onNext(Observable.just(2));
             }
         });
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
         subscriber.requestMore(1);
         subscriber.assertError(IllegalStateException.class);
         subscriber.assertNotCompleted();
@@ -189,7 +189,7 @@ public void testThrowException() throws InterruptedException {
             public void call(Long requested, Observer<Observable<? extends Integer>> observer) {
                 throw new TestException();
             }});
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
         subscriber.requestMore(1);
         subscriber.assertError(TestException.class);
         subscriber.assertNotCompleted();
@@ -209,7 +209,7 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
                 observer.onCompleted();
                 throw new TestException();
             }});
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
         subscriber.requestMore(1);
         subscriber.assertNoErrors();
         subscriber.assertCompleted();
@@ -230,7 +230,7 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
                 observer.onNext(Observable.just(1));
                 return 1;
             }});
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
         subscriber.requestMore(1);
         subscriber.assertNoErrors();
         subscriber.assertCompleted();
@@ -251,7 +251,7 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
                 observer.onNext(Observable.just(1));
                 return 1;
             }});
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
         subscriber.requestMore(1);
         subscriber.assertError(TestException.class);
         subscriber.assertNotCompleted();
@@ -272,7 +272,7 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
                 observer.onCompleted();
                 return state;
             }});
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
         subscriber.requestMore(1);
         subscriber.assertNoErrors();
         subscriber.assertCompleted();
@@ -293,7 +293,7 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
                 return state;
             }
         });
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
         subscriber.requestMore(1);
         subscriber.assertError(TestException.class);
         subscriber.assertNotCompleted();
@@ -315,7 +315,7 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
                 return state;
             }
         });
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
         subscriber.requestMore(1);
         subscriber.assertCompleted();
         subscriber.assertNoErrors();
@@ -359,7 +359,7 @@ public void call() {
                 observer.onNext(o1);
                 return state + 1;
             }});
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
         subscriber.requestMore(1); // [[1]]
         subscriber.requestMore(2); // [[2]]
         subscriber.requestMore(2); // onCompleted
@@ -413,7 +413,7 @@ public void call() {
                     }
                     return state + 1;
                 }});
-        Subscription subscription = Observable.create(os)
+        Subscription subscription = Observable.unsafeCreate(os)
             .observeOn(scheduler, 1)
             .subscribe(subscriber);
         sub.set(subscription);
@@ -465,7 +465,7 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
                 }
                 return state + 1;
             }});
-        Observable.create(os).subscribe(subscriber);
+        Observable.unsafeCreate(os).subscribe(subscriber);
 
         subscriber.assertNoErrors();
         subscriber.assertNotCompleted();
diff --git a/src/test/java/rx/observables/BlockingObservableTest.java b/src/test/java/rx/observables/BlockingObservableTest.java
index dfb57d26ff..fc802f978a 100644
--- a/src/test/java/rx/observables/BlockingObservableTest.java
+++ b/src/test/java/rx/observables/BlockingObservableTest.java
@@ -259,7 +259,7 @@ public void testToIterableManyTimes() {
 
     @Test(expected = TestException.class)
     public void testToIterableWithException() {
-        BlockingObservable<String> obs = BlockingObservable.from(Observable.create(new Observable.OnSubscribe<String>() {
+        BlockingObservable<String> obs = BlockingObservable.from(Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> observer) {
@@ -281,7 +281,7 @@ public void call(Subscriber<? super String> observer) {
     @Test
     public void testForEachWithError() {
         try {
-            BlockingObservable.from(Observable.create(new Observable.OnSubscribe<String>() {
+            BlockingObservable.from(Observable.unsafeCreate(new Observable.OnSubscribe<String>() {
 
                 @Override
                 public void call(final Subscriber<? super String> observer) {
@@ -382,7 +382,7 @@ public Boolean call(String args) {
     @Test
     public void testSingleOrDefaultUnsubscribe() throws InterruptedException {
         final CountDownLatch unsubscribe = new CountDownLatch(1);
-        Observable<Integer> o = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> o = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(Subscriber<? super Integer> subscriber) {
                 subscriber.add(Subscriptions.create(new Action0() {
diff --git a/src/test/java/rx/observables/SyncOnSubscribeTest.java b/src/test/java/rx/observables/SyncOnSubscribeTest.java
index 630561b0a3..a219e1d7b7 100644
--- a/src/test/java/rx/observables/SyncOnSubscribeTest.java
+++ b/src/test/java/rx/observables/SyncOnSubscribeTest.java
@@ -52,7 +52,7 @@ public void call(Observer<? super Integer> subscriber) {
 
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
 
-        Observable.create(os).subscribe(ts);
+        Observable.unsafeCreate(os).subscribe(ts);
 
         ts.assertNoErrors();
         ts.assertTerminalEvent();
@@ -82,7 +82,7 @@ public void call(Integer t) {
 
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
 
-        Observable.create(os).subscribe(ts);
+        Observable.unsafeCreate(os).subscribe(ts);
 
         ts.assertNoErrors();
         ts.assertTerminalEvent();
@@ -103,7 +103,7 @@ public void call(Observer<? super Integer> subscriber) {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
-        Observable.create(os).subscribe(o);
+        Observable.unsafeCreate(os).subscribe(o);
 
         verify(o, times(1)).onNext(1);
         verify(o, never()).onNext(2);
@@ -124,7 +124,7 @@ public void call(Observer<? super Integer> subscriber) {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
-        Observable.create(os).subscribe(o);
+        Observable.unsafeCreate(os).subscribe(o);
 
         verify(o, times(1)).onNext(1);
         verify(o, times(1)).onCompleted();
@@ -144,7 +144,7 @@ public void call(Observer<? super Integer> subscriber) {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
-        Observable.create(os).subscribe(o);
+        Observable.unsafeCreate(os).subscribe(o);
 
         verify(o, times(1)).onNext(1);
         verify(o, times(1)).onCompleted();
@@ -171,7 +171,7 @@ public void call(Observer<? super Integer> subscriber) {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
-        Observable.create(os).subscribe(o);
+        Observable.unsafeCreate(os).subscribe(o);
 
         verify(o, times(1)).onNext(1);
         verify(o, never()).onCompleted();
@@ -190,7 +190,7 @@ public void call(Observer<? super Integer> subscriber) {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
-        Observable.create(os).subscribe(o);
+        Observable.unsafeCreate(os).subscribe(o);
 
         verify(o, never()).onNext(any(Integer.class));
         verify(o, never()).onError(any(Throwable.class));
@@ -206,7 +206,7 @@ public void call(Observer<? super Integer> subscriber) {
             }});
 
 
-        Observable<Integer> neverObservable = Observable.create(os).subscribeOn(Schedulers.newThread());
+        Observable<Integer> neverObservable = Observable.unsafeCreate(os).subscribeOn(Schedulers.newThread());
         Observable<? extends Number> merged = Observable.amb(neverObservable, Observable.timer(100, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.newThread()));
         Iterator<? extends Number> values = merged.toBlocking().toIterable().iterator();
 
@@ -225,7 +225,7 @@ public void call(Observer<? super Integer> subscriber) {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
-        Observable.create(os).subscribe(o);
+        Observable.unsafeCreate(os).subscribe(o);
 
         verify(o, never()).onNext(any(Integer.class));
         verify(o, never()).onCompleted();
@@ -243,7 +243,7 @@ public void call(Observer<? super Integer> subscriber) {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
-        Observable.create(os).subscribe(o);
+        Observable.unsafeCreate(os).subscribe(o);
 
         verify(o, never()).onNext(any(Integer.class));
         verify(o, times(1)).onCompleted();
@@ -268,7 +268,7 @@ public void onStart() {
             }
         };
 
-        Observable.create(os).subscribe(ts);
+        Observable.unsafeCreate(os).subscribe(ts);
 
         ts.requestMore(1);
 
@@ -288,7 +288,7 @@ public void call(Observer<? super Integer> subscriber) {
         @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
-        Observable.create(os).subscribe(o);
+        Observable.unsafeCreate(os).subscribe(o);
 
         verify(o, never()).onNext(any(Integer.class));
         verify(o).onError(any(TestException.class));
@@ -319,7 +319,7 @@ public Integer call(Integer state, Observer<? super Integer> subscriber) {
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
 
-        Observable.create(os).subscribe(o);
+        Observable.unsafeCreate(os).subscribe(o);
 
         verify(o, never()).onError(any(TestException.class));
         inOrder.verify(o, times(count)).onNext(any(Integer.class));
@@ -357,7 +357,7 @@ public Iterator<Integer> call(Iterator<Integer> it, Observer<? super Integer> ob
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
 
-        Observable.create(os).subscribe(o);
+        Observable.unsafeCreate(os).subscribe(o);
 
         verify(o, never()).onError(any(TestException.class));
         inOrder.verify(o, times(n)).onNext(any());
@@ -385,7 +385,7 @@ public Integer call(Integer state, Observer<? super Integer> observer) {
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
 
-        Observable.create(os).take(finalCount).subscribe(o);
+        Observable.unsafeCreate(os).take(finalCount).subscribe(o);
 
         verify(o, never()).onError(any(Throwable.class));
         inOrder.verify(o, times(finalCount)).onNext(any());
@@ -416,7 +416,7 @@ public Integer call(Integer state, Observer<? super Integer> observer) {
                 onUnSubscribe);
 
         TestSubscriber<Object> ts = new TestSubscriber<Object>(0);
-        Observable.create(os).subscribe(ts);
+        Observable.unsafeCreate(os).subscribe(ts);
 
         ts.requestMore(finalCount);
 
@@ -451,7 +451,7 @@ public Integer call(Integer state, Observer<? super Integer> observer) {
 
         TestSubscriber<Object> ts = new TestSubscriber<Object>(o);
 
-        Observable.create(os).take(1).subscribe(ts);
+        Observable.unsafeCreate(os).take(1).subscribe(ts);
 
         verify(o, never()).onError(any(Throwable.class));
         verify(onUnSubscribe, times(1)).call(any(Integer.class));
@@ -521,7 +521,7 @@ public Integer call(Integer state, Observer<? super Integer> observer) {
         InOrder inOrder = inOrder(o);
 
         final TestSubscriber<Object> ts = new TestSubscriber<Object>(o);
-        Observable.create(os).subscribeOn(Schedulers.newThread()).subscribe(ts);
+        Observable.unsafeCreate(os).subscribeOn(Schedulers.newThread()).subscribe(ts);
 
         // wait until the first request has started processing
         if (!l2.await(2, TimeUnit.SECONDS)) {
@@ -569,7 +569,7 @@ public void call() {
 
         final CountDownLatch latch = new CountDownLatch(1);
         final TestSubscriber<Object> ts = new TestSubscriber<Object>(o);
-        Observable.create(os).lift(new Operator<Void, Void>() {
+        Observable.unsafeCreate(os).lift(new Operator<Void, Void>() {
             @Override
             public Subscriber<? super Void> call(final Subscriber<? super Void> subscriber) {
                 return new Subscriber<Void>(subscriber) {
@@ -634,7 +634,7 @@ public Map<Object, Object> call(Map<Object, Object> state, Observer<? super Inte
                 }},
             onUnSubscribe);
 
-        Observable<Integer> source = Observable.create(os);
+        Observable<Integer> source = Observable.unsafeCreate(os);
         for (int i = 0; i < count; i++) {
             source.subscribe();
         }
@@ -678,7 +678,7 @@ public void call(Integer t) {
             subs.add(ts);
         }
         TestScheduler scheduler = new TestScheduler();
-        Observable<Integer> o2 = Observable.create(os).subscribeOn(scheduler);
+        Observable<Integer> o2 = Observable.unsafeCreate(os).subscribeOn(scheduler);
         for (Subscriber<Object> ts : subs) {
             o2.subscribe(ts);
         }
@@ -719,7 +719,7 @@ public Integer call(Integer calls, Observer<? super Integer> observer) {
         TestSubscriber<Object> ts = new TestSubscriber<Object>();
 
         TestScheduler scheduler = new TestScheduler();
-        Observable.create(os).observeOn(scheduler).subscribe(ts);
+        Observable.unsafeCreate(os).observeOn(scheduler).subscribe(ts);
 
         scheduler.triggerActions();
         ts.awaitTerminalEvent();
@@ -748,7 +748,7 @@ public void call(Observer<? super Integer> observer) {
                     }},
                 onUnSubscribe);
         final AtomicReference<Throwable> exception = new AtomicReference<Throwable>();
-        Observable.create(os).subscribe(new Subscriber<Integer>() {
+        Observable.unsafeCreate(os).subscribe(new Subscriber<Integer>() {
             @Override
             public void onCompleted() {
 
diff --git a/src/test/java/rx/observers/SerializedObserverTest.java b/src/test/java/rx/observers/SerializedObserverTest.java
index b53ac9fd5d..83f49ecd52 100644
--- a/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/src/test/java/rx/observers/SerializedObserverTest.java
@@ -50,7 +50,7 @@ private Observer<String> serializedObserver(Observer<String> o) {
     @Test
     public void testSingleThreadedBasic() {
         TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable("one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
+        Observable<String> w = Observable.unsafeCreate(onSubscribe);
 
         Observer<String> aw = serializedObserver(observer);
 
@@ -70,7 +70,7 @@ public void testSingleThreadedBasic() {
     @Test
     public void testMultiThreadedBasic() {
         TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
+        Observable<String> w = Observable.unsafeCreate(onSubscribe);
 
         BusyObserver busyObserver = new BusyObserver();
         Observer<String> aw = serializedObserver(busyObserver);
@@ -94,7 +94,7 @@ public void testMultiThreadedBasic() {
     @Test(timeout = 1000)
     public void testMultiThreadedWithNPE() throws InterruptedException {
         TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null);
-        Observable<String> w = Observable.create(onSubscribe);
+        Observable<String> w = Observable.unsafeCreate(onSubscribe);
 
         BusyObserver busyObserver = new BusyObserver();
         Observer<String> aw = serializedObserver(busyObserver);
@@ -128,7 +128,7 @@ public void testMultiThreadedWithNPEinMiddle() {
         for (int i = 0; i < n; i++) {
             TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null,
                     "four", "five", "six", "seven", "eight", "nine");
-            Observable<String> w = Observable.create(onSubscribe);
+            Observable<String> w = Observable.unsafeCreate(onSubscribe);
 
             BusyObserver busyObserver = new BusyObserver();
             Observer<String> aw = serializedObserver(busyObserver);
@@ -391,7 +391,7 @@ private static void waitOnThreads(Future<?>... futures) {
     }
 
     private static Observable<String> infinite(final AtomicInteger produced) {
-        return Observable.create(new OnSubscribe<String>() {
+        return Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(Subscriber<? super String> s) {
diff --git a/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index a7cec8ab86..1a9541997c 100644
--- a/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -297,7 +297,7 @@ public void testRecursionAndOuterUnsubscribe() throws InterruptedException {
         final CountDownLatch completionLatch = new CountDownLatch(1);
         final Worker inner = getScheduler().createWorker();
         try {
-            Observable<Integer> obs = Observable.create(new OnSubscribe<Integer>() {
+            Observable<Integer> obs = Observable.unsafeCreate(new OnSubscribe<Integer>() {
                 @Override
                 public void call(final Subscriber<? super Integer> observer) {
                     inner.schedule(new Action0() {
diff --git a/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index 5875328d70..ff5c94071a 100644
--- a/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -322,7 +322,7 @@ public void call() {
 
     @Test
     public final void testRecursiveSchedulerInObservable() {
-        Observable<Integer> obs = Observable.create(new OnSubscribe<Integer>() {
+        Observable<Integer> obs = Observable.unsafeCreate(new OnSubscribe<Integer>() {
             @Override
             public void call(final Subscriber<? super Integer> observer) {
                 final Scheduler.Worker inner = getScheduler().createWorker();
@@ -362,7 +362,7 @@ public void call(Integer v) {
     public final void testConcurrentOnNextFailsValidation() throws InterruptedException {
         final int count = 10;
         final CountDownLatch latch = new CountDownLatch(count);
-        Observable<String> o = Observable.create(new OnSubscribe<String>() {
+        Observable<String> o = Observable.unsafeCreate(new OnSubscribe<String>() {
 
             @Override
             public void call(final Subscriber<? super String> observer) {
@@ -423,7 +423,7 @@ public final void testSubscribeOnNestedConcurrency() throws InterruptedException
 
                     @Override
                     public Observable<String> call(final String v) {
-                        return Observable.create(new OnSubscribe<String>() {
+                        return Observable.unsafeCreate(new OnSubscribe<String>() {
 
                             @Override
                             public void call(Subscriber<? super String> observer) {
diff --git a/src/test/java/rx/schedulers/TestSchedulerTest.java b/src/test/java/rx/schedulers/TestSchedulerTest.java
index 6c7b76e28e..f26939d5bf 100644
--- a/src/test/java/rx/schedulers/TestSchedulerTest.java
+++ b/src/test/java/rx/schedulers/TestSchedulerTest.java
@@ -181,7 +181,7 @@ public final void testNestedSchedule() {
             final Action0 calledOp = mock(Action0.class);
 
             Observable<Object> poller;
-            poller = Observable.create(new OnSubscribe<Object>() {
+            poller = Observable.unsafeCreate(new OnSubscribe<Object>() {
                 @Override
                 public void call(final Subscriber<? super Object> aSubscriber) {
                     inner.schedule(new Action0() {
diff --git a/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java b/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
index 72149ee677..954a9b8950 100644
--- a/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
@@ -52,7 +52,7 @@ public void testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther(
 
             @Override
             public void run() {
-                Observable.create(new OnSubscribe<Long>() {
+                Observable.unsafeCreate(new OnSubscribe<Long>() {
 
                     @Override
                     public void call(Subscriber<? super Long> o) {
diff --git a/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java b/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
index 5e1c350462..69b4c8cf69 100644
--- a/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
@@ -52,7 +52,7 @@ public void testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther(
 
             @Override
             public void run() {
-                Observable.create(new OnSubscribe<Long>() {
+                Observable.unsafeCreate(new OnSubscribe<Long>() {
 
                     @Override
                     public void call(Subscriber<? super Long> o) {
@@ -174,7 +174,7 @@ public static void concurrencyTest(final ReplaySubject<Long> replay) throws Inte
 
             @Override
             public void run() {
-                Observable.create(new OnSubscribe<Long>() {
+                Observable.unsafeCreate(new OnSubscribe<Long>() {
 
                     @Override
                     public void call(Subscriber<? super Long> o) {

From 828db38e3c895a66dab440652c07427455da226d Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 11 Feb 2017 10:36:18 +0100
Subject: [PATCH 218/263] 1.x: create+subscribeOn avoid same-pool deadlock
 (#5091)

---
 src/main/java/rx/Observable.java              |  46 ++++++-
 .../operators/OperatorSubscribeOn.java        | 114 +++++++++++-------
 .../operators/OperatorGroupByTest.java        |   4 +-
 .../operators/OperatorSubscribeOnTest.java    |  93 ++++++++++++--
 4 files changed, 199 insertions(+), 58 deletions(-)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 89e1aea07c..bdc59e33ce 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -10333,11 +10333,15 @@ static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T
     /**
      * Asynchronously subscribes Observers to this Observable on the specified {@link Scheduler}.
      * <p>
+     * If there is a {@link #create(Action1, rx.Emitter.BackpressureMode)} type source up in the
+     * chain, it is recommended to use {@code subscribeOn(scheduler, false)} instead
+     * to avoid same-pool deadlock because requests pile up behind a eager/blocking emitter.
+     * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/subscribeOn.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
-     *  <dd>The operator doesn't interfere with backpressure which is determined by the source {@code Observable}'s backpressure
-     *  behavior.</dd>
+     *  <dd>The operator doesn't interfere with backpressure amount which is determined by the source {@code Observable}'s backpressure
+     *  behavior. However, the upstream is requested from the given scheduler thread.</dd>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
@@ -10349,12 +10353,48 @@ static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T
      * @see <a href="http://reactivex.io/documentation/operators/subscribeon.html">ReactiveX operators documentation: SubscribeOn</a>
      * @see <a href="http://www.grahamlea.com/2014/07/rxjava-threading-examples/">RxJava Threading Examples</a>
      * @see #observeOn
+     * @see #subscribeOn(Scheduler, boolean)
      */
     public final Observable<T> subscribeOn(Scheduler scheduler) {
+        return subscribeOn(scheduler, !(this.onSubscribe instanceof OnSubscribeCreate));
+    }
+
+    /**
+     * Asynchronously subscribes Observers to this Observable on the specified {@link Scheduler} and
+     * optionally reroutes requests from other threads to the same {@link Scheduler} thread.
+     * <p>
+     * If there is a {@link #create(Action1, rx.Emitter.BackpressureMode)} type source up in the
+     * chain, it is recommended to have {@code requestOn} false to avoid same-pool deadlock
+     * because requests pile up behind a eager/blocking emitter.
+     * <p>
+     * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/subscribeOn.png" alt="">
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator doesn't interfere with backpressure amount which is determined by the source {@code Observable}'s backpressure
+     *  behavior. However, the upstream is requested from the given scheduler if requestOn is true.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>you specify which {@link Scheduler} this operator will use</dd>
+     * </dl>
+     *
+     * @param scheduler
+     *            the {@link Scheduler} to perform subscription actions on
+     * @param requestOn if true, requests are rerouted to the given Scheduler as well (strong pipelining)
+     *                  if false, requests coming from any thread are simply forwarded to
+     *                  the upstream on the same thread (weak pipelining)
+     * @return the source Observable modified so that its subscriptions happen on the
+     *         specified {@link Scheduler}
+     * @see <a href="http://reactivex.io/documentation/operators/subscribeon.html">ReactiveX operators documentation: SubscribeOn</a>
+     * @see <a href="http://www.grahamlea.com/2014/07/rxjava-threading-examples/">RxJava Threading Examples</a>
+     * @see #observeOn
+     * @see #subscribeOn(Scheduler)
+     * @since 1.2.7 - experimental
+     */
+    @Experimental
+    public final Observable<T> subscribeOn(Scheduler scheduler, boolean requestOn) {
         if (this instanceof ScalarSynchronousObservable) {
             return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
         }
-        return unsafeCreate(new OperatorSubscribeOn<T>(this, scheduler));
+        return unsafeCreate(new OperatorSubscribeOn<T>(this, scheduler, requestOn));
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/OperatorSubscribeOn.java b/src/main/java/rx/internal/operators/OperatorSubscribeOn.java
index 9b90cbc26a..0be1b01829 100644
--- a/src/main/java/rx/internal/operators/OperatorSubscribeOn.java
+++ b/src/main/java/rx/internal/operators/OperatorSubscribeOn.java
@@ -31,68 +31,92 @@ public final class OperatorSubscribeOn<T> implements OnSubscribe<T> {
 
     final Scheduler scheduler;
     final Observable<T> source;
+    final boolean requestOn;
 
-    public OperatorSubscribeOn(Observable<T> source, Scheduler scheduler) {
+    public OperatorSubscribeOn(Observable<T> source, Scheduler scheduler, boolean requestOn) {
         this.scheduler = scheduler;
         this.source = source;
+        this.requestOn = requestOn;
     }
 
     @Override
     public void call(final Subscriber<? super T> subscriber) {
         final Worker inner = scheduler.createWorker();
+
+        SubscribeOnSubscriber<T> parent = new SubscribeOnSubscriber<T>(subscriber, requestOn, inner, source);
+        subscriber.add(parent);
         subscriber.add(inner);
 
-        inner.schedule(new Action0() {
-            @Override
-            public void call() {
-                final Thread t = Thread.currentThread();
+        inner.schedule(parent);
+    }
 
-                Subscriber<T> s = new Subscriber<T>(subscriber) {
-                    @Override
-                    public void onNext(T t) {
-                        subscriber.onNext(t);
-                    }
+    static final class SubscribeOnSubscriber<T> extends Subscriber<T> implements Action0 {
 
-                    @Override
-                    public void onError(Throwable e) {
-                        try {
-                            subscriber.onError(e);
-                        } finally {
-                            inner.unsubscribe();
-                        }
-                    }
+        final Subscriber<? super T> actual;
 
-                    @Override
-                    public void onCompleted() {
-                        try {
-                            subscriber.onCompleted();
-                        } finally {
-                            inner.unsubscribe();
-                        }
-                    }
+        final boolean requestOn;
+
+        final Worker worker;
+
+        Observable<T> source;
+
+        Thread t;
+
+        SubscribeOnSubscriber(Subscriber<? super T> actual, boolean requestOn, Worker worker, Observable<T> source) {
+            this.actual = actual;
+            this.requestOn = requestOn;
+            this.worker = worker;
+            this.source = source;
+        }
 
-                    @Override
-                    public void setProducer(final Producer p) {
-                        subscriber.setProducer(new Producer() {
+        @Override
+        public void onNext(T t) {
+            actual.onNext(t);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            try {
+                actual.onError(e);
+            } finally {
+                worker.unsubscribe();
+            }
+        }
+
+        @Override
+        public void onCompleted() {
+            try {
+                actual.onCompleted();
+            } finally {
+                worker.unsubscribe();
+            }
+        }
+
+        @Override
+        public void call() {
+            Observable<T> src = source;
+            source = null;
+            t = Thread.currentThread();
+            src.unsafeSubscribe(this);
+        }
+
+        @Override
+        public void setProducer(final Producer p) {
+            actual.setProducer(new Producer() {
+                @Override
+                public void request(final long n) {
+                    if (t == Thread.currentThread() || !requestOn) {
+                        p.request(n);
+                    } else {
+                        worker.schedule(new Action0() {
                             @Override
-                            public void request(final long n) {
-                                if (t == Thread.currentThread()) {
-                                    p.request(n);
-                                } else {
-                                    inner.schedule(new Action0() {
-                                        @Override
-                                        public void call() {
-                                            p.request(n);
-                                        }
-                                    });
-                                }
+                            public void call() {
+                                p.request(n);
                             }
                         });
                     }
-                };
-
-                source.unsafeSubscribe(s);
-            }
-        });
+                }
+            });
+        }
     }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/internal/operators/OperatorGroupByTest.java b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
index 5d035bcd82..7fd6ab0a2e 100644
--- a/src/test/java/rx/internal/operators/OperatorGroupByTest.java
+++ b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
@@ -2017,11 +2017,11 @@ public Map<Integer, Object> call(Action1<Integer> t) {
                 throw exception;
             }};
     }
-    
+
     @Test
     public void outerConsumedInABoundedManner() {
         final int[] counter = { 0 };
-        
+
         Observable.range(1, 10000)
         .doOnRequest(new Action1<Long>() {
             @Override
diff --git a/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java b/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
index 6eb4abd8e8..b28b3fc27b 100644
--- a/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSubscribeOnTest.java
@@ -26,16 +26,12 @@
 
 import org.junit.Test;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.OnSubscribe;
 import rx.Observable.Operator;
-import rx.Observer;
-import rx.Producer;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.observers.TestSubscriber;
+import rx.functions.*;
+import rx.internal.util.*;
+import rx.observers.*;
 import rx.schedulers.Schedulers;
 
 public class OperatorSubscribeOnTest {
@@ -267,4 +263,85 @@ public void onNext(Integer t) {
         ts.assertNoErrors();
     }
 
+    @Test
+    public void noSamepoolDeadlock() {
+        final int n = 4 * RxRingBuffer.SIZE;
+
+        Observable.create(new Action1<Emitter<Object>>() {
+            @Override
+            public void call(Emitter<Object> e) {
+                for (int i = 0; i < n; i++) {
+                    e.onNext(i);
+                    try {
+                        Thread.sleep(1);
+                    } catch (InterruptedException e1) {
+                        e1.printStackTrace();
+                    }
+                }
+                e.onCompleted();
+            }
+        }, Emitter.BackpressureMode.DROP)
+        .map(UtilityFunctions.identity())
+        .subscribeOn(Schedulers.io(), false)
+        .observeOn(Schedulers.computation())
+        .test()
+        .awaitTerminalEvent(5, TimeUnit.SECONDS)
+        .assertValueCount(n)
+        .assertNoErrors()
+        .assertCompleted();
+    }
+
+    @Test
+    public void noSamepoolDeadlockRequestOn() {
+        final int n = 4 * RxRingBuffer.SIZE;
+
+        Observable.create(new Action1<Emitter<Object>>() {
+            @Override
+            public void call(Emitter<Object> e) {
+                for (int i = 0; i < n; i++) {
+                    e.onNext(i);
+                    try {
+                        Thread.sleep(1);
+                    } catch (InterruptedException e1) {
+                        e1.printStackTrace();
+                    }
+                }
+                e.onCompleted();
+            }
+        }, Emitter.BackpressureMode.DROP)
+        .subscribeOn(Schedulers.io())
+        .observeOn(Schedulers.computation())
+        .test()
+        .awaitTerminalEvent(5, TimeUnit.SECONDS)
+        .assertValueCount(n)
+        .assertNoErrors()
+        .assertCompleted();
+    }
+
+    @Test
+    public void noSamepoolDeadlockRequestOn2() {
+        final int n = 4 * RxRingBuffer.SIZE;
+
+        Observable.create(new Action1<Emitter<Object>>() {
+            @Override
+            public void call(Emitter<Object> e) {
+                for (int i = 0; i < n; i++) {
+                    e.onNext(i);
+                    try {
+                        Thread.sleep(1);
+                    } catch (InterruptedException e1) {
+                        e1.printStackTrace();
+                    }
+                }
+                e.onCompleted();
+            }
+        }, Emitter.BackpressureMode.DROP)
+        .subscribeOn(Schedulers.io(), true)
+        .observeOn(Schedulers.computation())
+        .test()
+        .awaitTerminalEvent(5, TimeUnit.SECONDS)
+        .assertValueCount(RxRingBuffer.SIZE)
+        .assertNoErrors()
+        .assertCompleted();
+    }
 }

From 5468972024dbbe5ee7cca080bc09a033b9488f37 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 11 Feb 2017 19:06:24 +0100
Subject: [PATCH 219/263] 1.x: add Single.merge(Obs), Obs.flatMapSingle &
 flatMapCompletable (#5092)

---
 src/main/java/rx/Observable.java              | 136 +++
 src/main/java/rx/Single.java                  |  91 ++
 .../OnSubscribeFlatMapCompletable.java        | 214 +++++
 .../operators/OnSubscribeFlatMapSingle.java   | 333 ++++++++
 src/test/java/rx/CompletableTest.java         |   4 +-
 .../OnSubscribeFlatMapCompletableTest.java    | 557 +++++++++++++
 .../OnSubscribeFlatMapSingleTest.java         | 782 ++++++++++++++++++
 7 files changed, 2115 insertions(+), 2 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeFlatMapCompletable.java
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeFlatMapSingle.java
 create mode 100644 src/test/java/rx/internal/operators/OnSubscribeFlatMapCompletableTest.java
 create mode 100644 src/test/java/rx/internal/operators/OnSubscribeFlatMapSingleTest.java

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index bdc59e33ce..5978412fc7 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -6973,6 +6973,74 @@ public final <U, R> Observable<R> flatMap(final Func1<? super T, ? extends Obser
         return merge(lift(new OperatorMapPair<T, U, R>(collectionSelector, resultSelector)), maxConcurrent);
     }
 
+    /**
+     * Maps all upstream values to Completables and runs them together until the upstream
+     * and all inner Completables complete normally.
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes items from upstream in an unbounded manner and ignores downstream backpressure
+     *  as it doesn't emit items but only terminal event.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code flatMapCompletable} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @param mapper the function that receives an upstream value and turns it into a Completable
+     *               to be merged.
+     * @return the new Observable instance
+     * @see #flatMapCompletable(Func1, boolean, int)
+     * @since 1.2.7 - experimental
+     */
+    @Experimental
+    public final Observable<T> flatMapCompletable(Func1<? super T, ? extends Completable> mapper) {
+        return flatMapCompletable(mapper, false, Integer.MAX_VALUE);
+    }
+
+    /**
+     * Maps all upstream values to Completables and runs them together, optionally delaying any errors, until the upstream
+     * and all inner Completables terminate.
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes items from upstream in an unbounded manner and ignores downstream backpressure
+     *  as it doesn't emit items but only terminal event.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code flatMapCompletable} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @param mapper the function that receives an upstream value and turns it into a Completable
+     *               to be merged.
+     * @param delayErrors if true, errors from the upstream and from the inner Completables get delayed till
+     *                    the all of them terminate.
+     * @return the new Observable instance
+     * @since 1.2.7 - experimental
+     * @see #flatMapCompletable(Func1, boolean, int)
+     */
+    @Experimental
+    public final Observable<T> flatMapCompletable(Func1<? super T, ? extends Completable> mapper, boolean delayErrors) {
+        return flatMapCompletable(mapper, delayErrors, Integer.MAX_VALUE);
+    }
+
+    /**
+     * Maps upstream values to Completables and runs up to the given number of them together at a time,
+     * optionally delaying any errors, until the upstream and all inner Completables terminate.
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes at most maxConcurrent items from upstream and one-by-one after as the inner
+     *  Completables terminate. The operator ignores downstream backpressure as it doesn't emit items but
+     *  only the terminal event.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code flatMapCompletable} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @param mapper the function that receives an upstream value and turns it into a Completable
+     *               to be merged.
+     * @param delayErrors if true, errors from the upstream and from the inner Completables get delayed till
+     *                    the all of them terminate.
+     * @param maxConcurrency the maximum number of inner Completables to run at a time
+     * @return the new Observable instance
+     * @since 1.2.7 - experimental
+     */
+    @Experimental
+    public final Observable<T> flatMapCompletable(Func1<? super T, ? extends Completable> mapper, boolean delayErrors, int maxConcurrency) {
+        return unsafeCreate(new OnSubscribeFlatMapCompletable<T>(this, mapper, delayErrors, maxConcurrency));
+    }
+
     /**
      * Returns an Observable that merges each item emitted by the source Observable with the values in an
      * Iterable corresponding to that item that is generated by a selector.
@@ -7106,6 +7174,74 @@ public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Ite
         return (Observable<R>)flatMap(OperatorMapPair.convertSelector(collectionSelector), resultSelector, maxConcurrent);
     }
 
+    /**
+     * Maps all upstream values to Singles and runs them together until the upstream
+     * and all inner Singles complete normally.
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes items from upstream in an unbounded manner and honors downstream backpressure.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @param <R> the value type of the inner Singles and the resulting Observable
+     * @param mapper the function that receives an upstream value and turns it into a Single
+     *               to be merged.
+     * @return the new Observable instance
+     * @see #flatMapSingle(Func1, boolean, int)
+     * @since 1.2.7 - experimental
+     */
+    @Experimental
+    public final <R> Observable<R> flatMapSingle(Func1<? super T, ? extends Single<? extends R>> mapper) {
+        return flatMapSingle(mapper, false, Integer.MAX_VALUE);
+    }
+
+    /**
+     * Maps all upstream values to Singles and runs them together, optionally delaying any errors, until the upstream
+     * and all inner Singles terminate.
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes items from upstream in an unbounded manner and honors downstream backpressure.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @param <R> the value type of the inner Singles and the resulting Observable
+     * @param mapper the function that receives an upstream value and turns it into a Single
+     *               to be merged.
+     * @param delayErrors if true, errors from the upstream and from the inner Singles get delayed till
+     *                    the all of them terminate.
+     * @return the new Observable instance
+     * @since 1.2.7 - experimental
+     * @see #flatMapSingle(Func1, boolean, int)
+     */
+    @Experimental
+    public final <R> Observable<R> flatMapSingle(Func1<? super T, ? extends Single<? extends R>> mapper, boolean delayErrors) {
+        return flatMapSingle(mapper, delayErrors, Integer.MAX_VALUE);
+    }
+
+    /**
+     * Maps upstream values to Singles and runs up to the given number of them together at a time,
+     * optionally delaying any errors, until the upstream and all inner Singles terminate.
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes at most maxConcurrent items from upstream and one-by-one after as the inner
+     *  Singles terminate. The operator honors downstream backpressure.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @param <R> the value type of the inner Singles and the resulting Observable
+     * @param mapper the function that receives an upstream value and turns it into a Single
+     *               to be merged.
+     * @param delayErrors if true, errors from the upstream and from the inner Singles get delayed till
+     *                    the all of them terminate.
+     * @param maxConcurrency the maximum number of inner Singles to run at a time
+     * @return the new Observable instance
+     * @since 1.2.7 - experimental
+     */
+    @Experimental
+    public final <R> Observable<R> flatMapSingle(Func1<? super T, ? extends Single<? extends R>> mapper, boolean delayErrors, int maxConcurrency) {
+        return unsafeCreate(new OnSubscribeFlatMapSingle<T, R>(this, mapper, delayErrors, maxConcurrency));
+    }
+
     /**
      * Subscribes to the {@link Observable} and receives notifications for each element.
      * <p>
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 709b709f41..a1614137f6 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -930,6 +930,97 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
         return Observable.merge(asObservable(t1), asObservable(t2), asObservable(t3), asObservable(t4), asObservable(t5), asObservable(t6), asObservable(t7), asObservable(t8), asObservable(t9));
     }
 
+    /**
+     * Merges all Singles emitted by the Observable and runs them together until the source
+     * Observable and all inner Singles complete normally.
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes items from the Observable in an unbounded manner and honors downstream backpressure.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @param <T> the value type of the inner Singles and the resulting Observable
+     * @param sources the Observable that emits Singles to be merged
+     * @return the new Observable instance
+     * @see #merge(Observable, int)
+     * @see #mergeDelayError(Observable)
+     * @see #mergeDelayError(Observable, int)
+     * @since 1.2.7 - experimental
+     */
+    @Experimental
+    public static <T> Observable<T> merge(Observable<? extends Single<? extends T>> sources) {
+        return merge(sources, Integer.MAX_VALUE);
+    }
+
+    /**
+     * Merges the Singles emitted by the Observable and runs up to the given number of them together at a time,
+     * until the Observable and all inner Singles terminate.
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes at most maxConcurrent items from the Observable and one-by-one after as the inner
+     *  Singles terminate. The operator ignores downstream backpressure as it doesn't emit items but
+     *  only the terminal event.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @param <T> the value type of the inner Singles and the resulting Observable
+     * @param sources the Observable that emits Singles to be merged
+     * @param maxConcurrency the maximum number of inner Singles to run at a time
+     * @return the new Observable instance
+     * @since 1.2.7 - experimental
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Experimental
+    public static <T> Observable<T> merge(Observable<? extends Single<? extends T>> sources, int maxConcurrency) {
+        return sources.flatMapSingle((Func1)UtilityFunctions.identity(), false, maxConcurrency);
+    }
+
+    /**
+     * Merges all Singles emitted by the Observable and runs them together,
+     * delaying errors from them and the Observable, until the source
+     * Observable and all inner Singles complete normally.
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes items from the Observable in an unbounded manner and honors downstream backpressure.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @param <T> the value type of the inner Singles and the resulting Observable
+     * @param sources the Observable that emits Singles to be merged
+     * @return the new Observable instance
+     * @see #mergeDelayError(Observable, int)
+     * @see #merge(Observable)
+     * @see #merge(Observable, int)
+     * @since 1.2.7 - experimental
+     */
+    @Experimental
+    public static <T> Observable<T> mergeDelayError(Observable<? extends Single<? extends T>> sources) {
+        return merge(sources, Integer.MAX_VALUE);
+    }
+
+    /**
+     * Merges the Singles emitted by the Observable and runs up to the given number of them together at a time,
+     * delaying errors from them and the Observable, until the Observable and all inner Singles terminate.
+     * <dl>
+     *  <dt><b>Backpressure:</b></dt>
+     *  <dd>The operator consumes at most maxConcurrent items from the Observable and one-by-one after as the inner
+     *  Singles terminate. The operator ignores downstream backpressure as it doesn't emit items but
+     *  only the terminal event.</dd>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @param <T> the value type of the inner Singles and the resulting Observable
+     * @param sources the Observable that emits Singles to be merged
+     * @param maxConcurrency the maximum number of inner Singles to run at a time
+     * @return the new Observable instance
+     * @since 1.2.7 - experimental
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Experimental
+    public static <T> Observable<T> mergeDelayError(Observable<? extends Single<? extends T>> sources, int maxConcurrency) {
+        return sources.flatMapSingle((Func1)UtilityFunctions.identity(), true, maxConcurrency);
+    }
+
     /**
      * Returns a Single that emits the results of a specified combiner function applied to two items emitted by
      * two other Singles.
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFlatMapCompletable.java b/src/main/java/rx/internal/operators/OnSubscribeFlatMapCompletable.java
new file mode 100644
index 0000000000..bfb8d6d69a
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeFlatMapCompletable.java
@@ -0,0 +1,214 @@
+/**
+ * Copyright 2017 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.atomic.*;
+
+import rx.*;
+import rx.exceptions.Exceptions;
+import rx.functions.Func1;
+import rx.internal.util.ExceptionsUtils;
+import rx.plugins.RxJavaHooks;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Maps upstream values to Completables and merges them, up to a given
+ * number of them concurrently, optionally delaying errors.
+ * @param <T> the upstream value type
+ * @since 1.2.7 - experimental
+ */
+public final class OnSubscribeFlatMapCompletable<T> implements Observable.OnSubscribe<T> {
+
+    final Observable<T> source;
+
+    final Func1<? super T, ? extends Completable> mapper;
+
+    final boolean delayErrors;
+
+    final int maxConcurrency;
+
+    public OnSubscribeFlatMapCompletable(Observable<T> source, Func1<? super T, ? extends Completable> mapper,
+            boolean delayErrors, int maxConcurrency) {
+        if (mapper == null) {
+            throw new NullPointerException("mapper is null");
+        }
+        if (maxConcurrency <= 0) {
+            throw new IllegalArgumentException("maxConcurrency > 0 required but it was " + maxConcurrency);
+        }
+        this.source = source;
+        this.mapper = mapper;
+        this.delayErrors = delayErrors;
+        this.maxConcurrency = maxConcurrency;
+    }
+
+    @Override
+    public void call(Subscriber<? super T> child) {
+        FlatMapCompletableSubscriber<T> parent = new FlatMapCompletableSubscriber<T>(child, mapper, delayErrors, maxConcurrency);
+        child.add(parent);
+        child.add(parent.set);
+        source.unsafeSubscribe(parent);
+    }
+
+    static final class FlatMapCompletableSubscriber<T> extends Subscriber<T> {
+
+        final Subscriber<? super T> actual;
+
+        final Func1<? super T, ? extends Completable> mapper;
+
+        final boolean delayErrors;
+
+        final int maxConcurrency;
+
+        final AtomicInteger wip;
+
+        final CompositeSubscription set;
+
+        final AtomicReference<Throwable> errors;
+
+        FlatMapCompletableSubscriber(Subscriber<? super T> actual, Func1<? super T, ? extends Completable> mapper,
+                boolean delayErrors, int maxConcurrency) {
+            this.actual = actual;
+            this.mapper = mapper;
+            this.delayErrors = delayErrors;
+            this.maxConcurrency = maxConcurrency;
+            this.wip = new AtomicInteger(1);
+            this.errors = new AtomicReference<Throwable>();
+            this.set = new CompositeSubscription();
+            this.request(maxConcurrency != Integer.MAX_VALUE ? maxConcurrency : Long.MAX_VALUE);
+        }
+
+        @Override
+        public void onNext(T t) {
+            Completable c;
+
+            try {
+                c = mapper.call(t);
+                if (c == null) {
+                    throw new NullPointerException("The mapper returned a null Completable");
+                }
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                onError(ex);
+                return;
+            }
+
+            InnerSubscriber inner = new InnerSubscriber();
+            set.add(inner);
+            wip.getAndIncrement();
+
+            c.unsafeSubscribe(inner);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            if (delayErrors) {
+                ExceptionsUtils.addThrowable(errors, e);
+                onCompleted();
+            } else {
+                set.unsubscribe();
+                if (errors.compareAndSet(null, e)) {
+                    actual.onError(ExceptionsUtils.terminate(errors));
+                } else {
+                    RxJavaHooks.onError(e);
+                }
+            }
+        }
+
+        @Override
+        public void onCompleted() {
+            done();
+        }
+
+        boolean done() {
+            if (wip.decrementAndGet() == 0) {
+                Throwable ex = ExceptionsUtils.terminate(errors);
+                if (ex != null) {
+                    actual.onError(ex);
+                } else {
+                    actual.onCompleted();
+                }
+                return true;
+            }
+            return false;
+        }
+
+        public void innerError(InnerSubscriber inner, Throwable e) {
+            set.remove(inner);
+            if (delayErrors) {
+                ExceptionsUtils.addThrowable(errors, e);
+                if (!done() && maxConcurrency != Integer.MAX_VALUE) {
+                    request(1);
+                }
+            } else {
+                set.unsubscribe();
+                unsubscribe();
+                if (errors.compareAndSet(null, e)) {
+                    actual.onError(ExceptionsUtils.terminate(errors));
+                } else {
+                    RxJavaHooks.onError(e);
+                }
+            }
+        }
+
+        public void innerComplete(InnerSubscriber inner) {
+            set.remove(inner);
+            if (!done() && maxConcurrency != Integer.MAX_VALUE) {
+                request(1);
+            }
+        }
+
+        final class InnerSubscriber
+        extends AtomicReference<Subscription>
+        implements CompletableSubscriber, Subscription {
+
+            private static final long serialVersionUID = -8588259593722659900L;
+
+            @Override
+            public void unsubscribe() {
+                Subscription s = getAndSet(this);
+                if (s != null && s != this) {
+                    s.unsubscribe();
+                }
+            }
+
+            @Override
+            public boolean isUnsubscribed() {
+                return get() == this;
+            }
+
+            @Override
+            public void onCompleted() {
+                innerComplete(this);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                innerError(this, e);
+            }
+
+            @Override
+            public void onSubscribe(Subscription d) {
+                if (!compareAndSet(null, d)) {
+                    d.unsubscribe();
+                    if (get() != this) {
+                        RxJavaHooks.onError(new IllegalStateException("Subscription already set!"));
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFlatMapSingle.java b/src/main/java/rx/internal/operators/OnSubscribeFlatMapSingle.java
new file mode 100644
index 0000000000..b64a4ef760
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeFlatMapSingle.java
@@ -0,0 +1,333 @@
+/**
+ * Copyright 2017 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.Queue;
+import java.util.concurrent.atomic.*;
+
+import rx.*;
+import rx.exceptions.Exceptions;
+import rx.functions.Func1;
+import rx.internal.util.ExceptionsUtils;
+import rx.internal.util.atomic.MpscLinkedAtomicQueue;
+import rx.internal.util.unsafe.*;
+import rx.plugins.RxJavaHooks;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Maps upstream values to Singles and merges them, up to a given
+ * number of them concurrently, optionally delaying errors.
+ * @param <T> the upstream value type
+ * @param <R> the inner Singles and result value type
+ * @since 1.2.7 - experimental
+ */
+public final class OnSubscribeFlatMapSingle<T, R> implements Observable.OnSubscribe<R> {
+
+    final Observable<T> source;
+
+    final Func1<? super T, ? extends Single<? extends R>> mapper;
+
+    final boolean delayErrors;
+
+    final int maxConcurrency;
+
+    public OnSubscribeFlatMapSingle(Observable<T> source, Func1<? super T, ? extends Single<? extends R>> mapper,
+            boolean delayErrors, int maxConcurrency) {
+        if (mapper == null) {
+            throw new NullPointerException("mapper is null");
+        }
+        if (maxConcurrency <= 0) {
+            throw new IllegalArgumentException("maxConcurrency > 0 required but it was " + maxConcurrency);
+        }
+        this.source = source;
+        this.mapper = mapper;
+        this.delayErrors = delayErrors;
+        this.maxConcurrency = maxConcurrency;
+    }
+
+    @Override
+    public void call(Subscriber<? super R> child) {
+        FlatMapSingleSubscriber<T, R> parent = new FlatMapSingleSubscriber<T, R>(child, mapper, delayErrors, maxConcurrency);
+        child.add(parent.set);
+        child.add(parent.requested);
+        child.setProducer(parent.requested);
+        source.unsafeSubscribe(parent);
+    }
+
+    static final class FlatMapSingleSubscriber<T, R> extends Subscriber<T> {
+
+        final Subscriber<? super R> actual;
+
+        final Func1<? super T, ? extends Single<? extends R>> mapper;
+
+        final boolean delayErrors;
+
+        final int maxConcurrency;
+
+        final AtomicInteger wip;
+
+        final AtomicInteger active;
+
+        final CompositeSubscription set;
+
+        final AtomicReference<Throwable> errors;
+
+        final Queue<Object> queue;
+
+        final Requested requested;
+
+        volatile boolean done;
+
+        volatile boolean cancelled;
+
+        FlatMapSingleSubscriber(Subscriber<? super R> actual,
+                Func1<? super T, ? extends Single<? extends R>> mapper,
+                boolean delayErrors, int maxConcurrency) {
+            this.actual = actual;
+            this.mapper = mapper;
+            this.delayErrors = delayErrors;
+            this.maxConcurrency = maxConcurrency;
+            this.wip = new AtomicInteger();
+            this.errors = new AtomicReference<Throwable>();
+            this.requested = new Requested();
+            this.set = new CompositeSubscription();
+            this.active = new AtomicInteger();
+            if (UnsafeAccess.isUnsafeAvailable()) {
+                queue = new MpscLinkedQueue<Object>();
+            } else {
+                queue = new MpscLinkedAtomicQueue<Object>();
+            }
+            this.request(maxConcurrency != Integer.MAX_VALUE ? maxConcurrency : Long.MAX_VALUE);
+        }
+
+        @Override
+        public void onNext(T t) {
+            Single<? extends R> c;
+
+            try {
+                c = mapper.call(t);
+                if (c == null) {
+                    throw new NullPointerException("The mapper returned a null Single");
+                }
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                onError(ex);
+                return;
+            }
+
+            InnerSubscriber inner = new InnerSubscriber();
+            set.add(inner);
+            active.incrementAndGet();
+
+            c.subscribe(inner);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            if (delayErrors) {
+                ExceptionsUtils.addThrowable(errors, e);
+            } else {
+                set.unsubscribe();
+                if (!errors.compareAndSet(null, e)) {
+                    RxJavaHooks.onError(e);
+                    return;
+                }
+            }
+            done = true;
+            drain();
+        }
+
+        @Override
+        public void onCompleted() {
+            done = true;
+            drain();
+        }
+
+        void innerSuccess(InnerSubscriber inner, R value) {
+            queue.offer(NotificationLite.next(value));
+            set.remove(inner);
+            active.decrementAndGet();
+            drain();
+        }
+
+        void innerError(InnerSubscriber inner, Throwable e) {
+            if (delayErrors) {
+                ExceptionsUtils.addThrowable(errors, e);
+                set.remove(inner);
+                if (!done && maxConcurrency != Integer.MAX_VALUE) {
+                    request(1);
+                }
+            } else {
+                set.unsubscribe();
+                unsubscribe();
+                if (!errors.compareAndSet(null, e)) {
+                    RxJavaHooks.onError(e);
+                    return;
+                }
+                done = true;
+            }
+            active.decrementAndGet();
+            drain();
+        }
+
+        void drain() {
+            if (wip.getAndIncrement() != 0) {
+                return;
+            }
+
+            int missed = 1;
+            Subscriber<? super R> a = actual;
+            Queue<Object> q = queue;
+            boolean delayError = this.delayErrors;
+            AtomicInteger act = active;
+
+            for (;;) {
+                long r = requested.get();
+                long e = 0L;
+
+                while (e != r) {
+                    if (cancelled) {
+                        q.clear();
+                        return;
+                    }
+
+                    boolean d = done;
+
+                    if (!delayError && d) {
+                        Throwable ex = errors.get();
+                        if (ex != null) {
+                            q.clear();
+                            a.onError(ExceptionsUtils.terminate(errors));
+                            return;
+                        }
+                    }
+
+                    Object o = q.poll();
+
+                    boolean empty = o == null;
+
+                    if (d && act.get() == 0 && empty) {
+                        Throwable ex = errors.get();
+                        if (ex != null) {
+                            a.onError(ExceptionsUtils.terminate(errors));
+                        } else {
+                            a.onCompleted();
+                        }
+                        return;
+                    }
+
+                    if (empty) {
+                        break;
+                    }
+
+                    a.onNext(NotificationLite.<R>getValue(o));
+
+                    e++;
+                }
+
+                if (e == r) {
+                    if (cancelled) {
+                        q.clear();
+                        return;
+                    }
+
+                    if (done) {
+                        if (delayError) {
+                            if (act.get() == 0 && q.isEmpty()) {
+                                Throwable ex = errors.get();
+                                if (ex != null) {
+                                    a.onError(ExceptionsUtils.terminate(errors));
+                                } else {
+                                    a.onCompleted();
+                                }
+                                return;
+                            }
+                        } else {
+                            Throwable ex = errors.get();
+                            if (ex != null) {
+                                q.clear();
+                                a.onError(ExceptionsUtils.terminate(errors));
+                                return;
+                            }
+                            else if (act.get() == 0 && q.isEmpty()) {
+                                a.onCompleted();
+                                return;
+                            }
+                        }
+                    }
+                }
+
+                if (e != 0L) {
+                    requested.produced(e);
+                    if (!done && maxConcurrency != Integer.MAX_VALUE) {
+                        request(e);
+                    }
+                }
+
+                missed = wip.addAndGet(-missed);
+                if (missed == 0) {
+                    break;
+                }
+            }
+        }
+
+        final class Requested extends AtomicLong implements Producer, Subscription {
+
+            private static final long serialVersionUID = -887187595446742742L;
+
+            @Override
+            public void request(long n) {
+                if (n > 0L) {
+                    BackpressureUtils.getAndAddRequest(this, n);
+                    drain();
+                }
+            }
+
+            void produced(long e) {
+                BackpressureUtils.produced(this, e);
+            }
+
+            @Override
+            public void unsubscribe() {
+                cancelled = true;
+                FlatMapSingleSubscriber.this.unsubscribe();
+                if (wip.getAndIncrement() == 0) {
+                    queue.clear();
+                }
+            }
+
+            @Override
+            public boolean isUnsubscribed() {
+                return cancelled;
+            }
+        }
+
+        final class InnerSubscriber extends SingleSubscriber<R> {
+
+            @Override
+            public void onSuccess(R t) {
+                innerSuccess(this, t);
+            }
+
+            @Override
+            public void onError(Throwable error) {
+                innerError(this, error);
+            }
+        }
+    }
+}
diff --git a/src/test/java/rx/CompletableTest.java b/src/test/java/rx/CompletableTest.java
index 23418b60e6..3f34a983ca 100644
--- a/src/test/java/rx/CompletableTest.java
+++ b/src/test/java/rx/CompletableTest.java
@@ -93,7 +93,7 @@ public void remove() {
     /**
      * A class containing a completable instance and counts the number of subscribers.
      */
-    static final class NormalCompletable extends AtomicInteger {
+    public static final class NormalCompletable extends AtomicInteger {
         /** */
         private static final long serialVersionUID = 7192337844700923752L;
 
@@ -119,7 +119,7 @@ public void assertSubscriptions(int n) {
      * A class containing a completable instance that emits a TestException and counts
      * the number of subscribers.
      */
-    static final class ErrorCompletable extends AtomicInteger {
+    public static final class ErrorCompletable extends AtomicInteger {
         /** */
         private static final long serialVersionUID = 7192337844700923752L;
 
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFlatMapCompletableTest.java b/src/test/java/rx/internal/operators/OnSubscribeFlatMapCompletableTest.java
new file mode 100644
index 0000000000..2b88387400
--- /dev/null
+++ b/src/test/java/rx/internal/operators/OnSubscribeFlatMapCompletableTest.java
@@ -0,0 +1,557 @@
+/**
+ * Copyright 2017 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import static org.junit.Assert.*;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.*;
+
+import rx.*;
+import rx.CompletableTest.*;
+import rx.Observable;
+import rx.exceptions.*;
+import rx.functions.*;
+import rx.internal.util.UtilityFunctions;
+import rx.observers.*;
+import rx.schedulers.Schedulers;
+import rx.subjects.PublishSubject;
+import rx.subscriptions.Subscriptions;
+
+public class OnSubscribeFlatMapCompletableTest implements Action0, Action1<Object> {
+
+    final AtomicInteger calls = new AtomicInteger();
+
+    /** A normal Completable object. */
+    final NormalCompletable normal = new NormalCompletable();
+
+    /** An error Completable object. */
+    final ErrorCompletable error = new ErrorCompletable();
+
+    final Func1<Completable, Completable> identity = UtilityFunctions.identity();
+
+    @Override
+    public void call() {
+        calls.getAndIncrement();
+    }
+
+    @Override
+    public void call(Object t) {
+        calls.getAndIncrement();
+    }
+
+    void assertCalls(int n) {
+        assertEquals(n, calls.get());
+    }
+
+    @Test
+    public void normal() {
+        Observable.range(1, 10)
+        .flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(Integer v) {
+                return Completable.complete().doOnCompleted(OnSubscribeFlatMapCompletableTest.this);
+            }
+        })
+        .test()
+        .assertResult();
+
+        assertCalls(10);
+    }
+
+    @Test
+    public void normalMaxConcurrent() {
+        for (int i = 1; i < 10; i++) {
+            calls.set(0);
+
+            Observable.range(1, 10)
+            .flatMapCompletable(new Func1<Integer, Completable>() {
+                @Override
+                public Completable call(Integer v) {
+                    return Completable.complete()
+                            .observeOn(Schedulers.computation())
+                            .doOnCompleted(OnSubscribeFlatMapCompletableTest.this);
+                }
+            }, false, i)
+            .test()
+            .awaitTerminalEvent(5, TimeUnit.SECONDS)
+            .assertResult();
+
+            assertCalls(10);
+        }
+    }
+
+    @Test
+    public void error() {
+        Observable.range(1, 10)
+        .flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(Integer v) {
+                return Completable.error(new TestException()).doOnError(OnSubscribeFlatMapCompletableTest.this);
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+
+        assertCalls(1);
+    }
+
+    @Test
+    public void errorDelayed() {
+        AssertableSubscriber<Integer> as = Observable.range(1, 10)
+        .flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(Integer v) {
+                return Completable.error(new TestException()).doOnError(OnSubscribeFlatMapCompletableTest.this);
+            }
+        }, true)
+        .test()
+        .assertFailure(CompositeException.class);
+
+        List<Throwable> onErrorEvents = as.getOnErrorEvents();
+
+        assertEquals(onErrorEvents.toString(), 1, onErrorEvents.size());
+
+        onErrorEvents = ((CompositeException)onErrorEvents.get(0)).getExceptions();
+
+        assertEquals(onErrorEvents.toString(), 10, onErrorEvents.size());
+
+        for (Throwable ex : onErrorEvents) {
+            assertTrue(ex.toString(), ex instanceof TestException);
+        }
+
+        assertCalls(10);
+    }
+
+    @Test
+    public void errorDelayedMaxConcurrency() {
+        AssertableSubscriber<Integer> as = Observable.range(1, 10)
+        .flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(Integer v) {
+                return Completable.error(new TestException()).doOnError(OnSubscribeFlatMapCompletableTest.this);
+            }
+        }, true, 1)
+        .test()
+        .assertFailure(CompositeException.class);
+
+        List<Throwable> onErrorEvents = as.getOnErrorEvents();
+
+        assertEquals(onErrorEvents.toString(), 1, onErrorEvents.size());
+
+        onErrorEvents = ((CompositeException)onErrorEvents.get(0)).getExceptions();
+
+        assertEquals(onErrorEvents.toString(), 10, onErrorEvents.size());
+
+        for (Throwable ex : onErrorEvents) {
+            assertTrue(ex.toString(), ex instanceof TestException);
+        }
+
+        assertCalls(10);
+    }
+
+    @Test
+    public void mapperThrows() {
+        Observable.range(1, 10)
+        .flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(Integer v) {
+                throw new TestException();
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+    }
+
+    @Test
+    public void mapperNull() {
+        Observable.range(1, 10)
+        .flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(Integer v) {
+                return null;
+            }
+        })
+        .test()
+        .assertFailure(NullPointerException.class);
+    }
+
+    @Test
+    public void paramValidation() {
+        try {
+            Observable.range(1, 10)
+            .flatMapCompletable(null);
+            fail("Should have thrown");
+        } catch (NullPointerException ex) {
+            assertEquals("mapper is null", ex.getMessage());
+        }
+
+        try {
+            Observable.range(1, 10)
+            .flatMapCompletable(new Func1<Integer, Completable>() {
+                @Override
+                public Completable call(Integer v) {
+                    return Completable.complete();
+                }
+            }, false, 0);
+            fail("Should have thrown");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("maxConcurrency > 0 required but it was 0", ex.getMessage());
+        }
+
+        try {
+            Observable.range(1, 10)
+            .flatMapCompletable(new Func1<Integer, Completable>() {
+                @Override
+                public Completable call(Integer v) {
+                    return Completable.complete();
+                }
+            }, true, -99);
+            fail("Should have thrown");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("maxConcurrency > 0 required but it was -99", ex.getMessage());
+        }
+    }
+
+    @Test
+    public void mainErrorDelayed() {
+        Observable.range(1, 10).concatWith(Observable.<Integer>error(new TestException()))
+        .flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(Integer v) {
+                return Completable.complete().doOnCompleted(OnSubscribeFlatMapCompletableTest.this);
+            }
+        }, true)
+        .test()
+        .assertFailure(TestException.class);
+
+        assertCalls(10);
+    }
+
+    @Test
+    public void innerDoubleOnSubscribe() {
+        final CompletableSubscriber[] inner = { null };
+
+        AssertableSubscriber<Integer> as = Observable.just(1)
+        .flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(Integer t) {
+                return Completable.create(new Completable.OnSubscribe() {
+                    @Override
+                    public void call(CompletableSubscriber t) {
+                        OnSubscribeFlatMapCompletableTest.this.call();
+                        Subscription s1 = Subscriptions.empty();
+
+                        t.onSubscribe(s1);
+
+                        Subscription s2 = Subscriptions.empty();
+
+                        t.onSubscribe(s2);
+
+                        if (s2.isUnsubscribed()) {
+                            OnSubscribeFlatMapCompletableTest.this.call();
+                        }
+
+                        t.onCompleted();
+
+                        inner[0] = t;
+                    }
+                });
+            }
+        })
+        .test()
+        .assertResult();
+
+        assertCalls(2);
+
+        inner[0].onError(new TestException());
+
+        as.assertResult();
+    }
+
+    @Test
+    public void mainErrorUnsubscribes() {
+        PublishSubject<Integer> ps0 = PublishSubject.create();
+        final PublishSubject<Integer> ps1 = PublishSubject.create();
+        final PublishSubject<Integer> ps2 = PublishSubject.create();
+
+        TestSubscriber<Integer> as = TestSubscriber.create();
+
+        ps0.flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(Integer v) {
+                return v == 0 ? ps1.toCompletable() : ps2.toCompletable();
+            }
+        }).unsafeSubscribe(as);
+
+        assertTrue(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(0);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(1);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertTrue(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onError(new TestException());
+
+        assertFalse(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertError(TestException.class);
+        as.assertNotCompleted();
+    }
+
+    @Test
+    public void innerErrorUnsubscribes() {
+        PublishSubject<Integer> ps0 = PublishSubject.create();
+        final PublishSubject<Integer> ps1 = PublishSubject.create();
+        final PublishSubject<Integer> ps2 = PublishSubject.create();
+
+        TestSubscriber<Integer> as = TestSubscriber.create();
+
+        ps0.flatMapCompletable(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(Integer v) {
+                return v == 0 ? ps1.toCompletable() : ps2.toCompletable();
+            }
+        }).unsafeSubscribe(as);
+
+        assertTrue(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(0);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(1);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertTrue(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps1.onError(new TestException());
+
+        assertFalse(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertError(TestException.class);
+        as.assertNotCompleted();
+    }
+
+
+    @Test(timeout = 5000)
+    public void mergeObservableEmpty() {
+        Completable c = Observable.<Completable>empty().flatMapCompletable(identity).toCompletable();
+
+        c.await();
+    }
+
+    @Test(timeout = 5000, expected = TestException.class)
+    public void mergeObservableError() {
+        Completable c = Observable.<Completable>error(new TestException()).flatMapCompletable(identity).toCompletable();
+
+        c.await();
+    }
+
+    @Test(timeout = 5000)
+    public void mergeObservableSingle() {
+        Completable c = Observable.just(normal.completable).flatMapCompletable(identity).toCompletable();
+
+        c.await();
+
+        normal.assertSubscriptions(1);
+    }
+
+    @Test(timeout = 5000, expected = TestException.class)
+    public void mergeObservableSingleThrows() {
+        Completable c = Observable.just(error.completable).flatMapCompletable(identity).toCompletable();
+
+        c.await();
+    }
+
+    @Test(timeout = 5000)
+    public void mergeObservableMany() {
+        Completable c = Observable.just(normal.completable).repeat(3).flatMapCompletable(identity).toCompletable();
+
+        c.await();
+
+        normal.assertSubscriptions(3);
+    }
+
+    @Test(timeout = 5000, expected = TestException.class)
+    public void mergeObservableManyOneThrows() {
+        Completable c = Observable.just(normal.completable, error.completable).flatMapCompletable(identity).toCompletable();
+
+        c.await();
+    }
+
+    @Test(timeout = 5000)
+    public void mergeObservableMaxConcurrent() {
+        final List<Long> requested = new ArrayList<Long>();
+        Observable<Completable> cs = Observable
+                .just(normal.completable)
+                .repeat(10)
+                .doOnRequest(new Action1<Long>() {
+                    @Override
+                    public void call(Long v) {
+                        requested.add(v);
+                    }
+                });
+
+        Completable c = cs.flatMapCompletable(identity, false, 5).toCompletable();
+
+        c.await();
+
+        // FIXME this request pattern looks odd because all 10 completions trigger 1 requests
+        Assert.assertEquals(Arrays.asList(5L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L), requested);
+    }
+
+    @Test(timeout = 5000)
+    public void mergeDelayErrorObservableEmpty() {
+        Completable c = Observable.<Completable>empty().flatMapCompletable(identity, true).toCompletable();
+
+        c.await();
+    }
+
+    @Test(timeout = 5000, expected = TestException.class)
+    public void mergeDelayErrorObservableError() {
+        Completable c = Observable.<Completable>error(new TestException()).flatMapCompletable(identity, true).toCompletable();
+
+        c.await();
+    }
+
+    @Test(timeout = 5000)
+    public void mergeDelayErrorObservableSingle() {
+        Completable c = Observable.just(normal.completable).flatMapCompletable(identity, true).toCompletable();
+
+        c.await();
+
+        normal.assertSubscriptions(1);
+    }
+
+    @Test(timeout = 5000, expected = TestException.class)
+    public void mergeDelayErrorObservableSingleThrows() {
+        Completable c = Observable.just(error.completable).flatMapCompletable(identity, true).toCompletable();
+
+        c.await();
+    }
+
+    @Test(timeout = 5000)
+    public void mergeDelayErrorObservableMany() {
+        Completable c = Observable.just(normal.completable).repeat(3).flatMapCompletable(identity, true).toCompletable();
+
+        c.await();
+
+        normal.assertSubscriptions(3);
+    }
+
+    @Test(timeout = 5000, expected = TestException.class)
+    public void mergeDelayErrorObservableManyOneThrows() {
+        Completable c = Observable.just(normal.completable, error.completable).flatMapCompletable(identity, true).toCompletable();
+
+        c.await();
+    }
+
+    @Test(timeout = 5000)
+    public void mergeDelayErrorObservableMaxConcurrent() {
+        final List<Long> requested = new ArrayList<Long>();
+        Observable<Completable> cs = Observable
+                .just(normal.completable)
+                .repeat(10)
+                .doOnRequest(new Action1<Long>() {
+                    @Override
+                    public void call(Long v) {
+                        requested.add(v);
+                    }
+                });
+
+        Completable c = cs.flatMapCompletable(identity, true, 5).toCompletable();
+
+        c.await();
+
+        // FIXME this request pattern looks odd because all 10 completions trigger 1 requests
+        Assert.assertEquals(Arrays.asList(5L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L), requested);
+    }
+
+    @Test
+    public void asyncObservables() {
+
+        final int[] calls = { 0 };
+
+        Observable.range(1, 5).map(new Func1<Integer, Completable>() {
+            @Override
+            public Completable call(final Integer v) {
+                System.out.println("Mapping " + v);
+                return Completable.fromAction(new Action0() {
+                    @Override
+                    public void call() {
+                        System.out.println("Processing " + (calls[0] + 1));
+                        calls[0]++;
+                    }
+                })
+                .subscribeOn(Schedulers.io())
+                .doOnCompleted(new Action0() {
+                    @Override
+                    public void call() {
+                        System.out.println("Inner complete " + v);
+                    }
+                })
+                .observeOn(Schedulers.computation());
+            }
+        }).flatMapCompletable(identity, false, 1).toCompletable()
+        .test()
+        .awaitTerminalEventAndUnsubscribeOnTimeout(5, TimeUnit.SECONDS)
+        .assertResult();
+
+        Assert.assertEquals(5, calls[0]);
+    }
+
+}
diff --git a/src/test/java/rx/internal/operators/OnSubscribeFlatMapSingleTest.java b/src/test/java/rx/internal/operators/OnSubscribeFlatMapSingleTest.java
new file mode 100644
index 0000000000..3da2ac389c
--- /dev/null
+++ b/src/test/java/rx/internal/operators/OnSubscribeFlatMapSingleTest.java
@@ -0,0 +1,782 @@
+/**
+ * Copyright 2017 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+
+import rx.*;
+import rx.Observable;
+import rx.exceptions.*;
+import rx.functions.*;
+import rx.observers.*;
+import rx.schedulers.Schedulers;
+import rx.subjects.PublishSubject;
+
+public class OnSubscribeFlatMapSingleTest implements Action0, Action1<Object> {
+
+    final AtomicInteger calls = new AtomicInteger();
+
+    final Action1<Throwable> errorConsumer = new Action1<Throwable>() {
+        @Override
+        public void call(Throwable e) {
+            OnSubscribeFlatMapSingleTest.this.call(e);
+        }
+    };
+
+    @Override
+    public void call() {
+        calls.getAndIncrement();
+    }
+
+    @Override
+    public void call(Object t) {
+        calls.getAndIncrement();
+    }
+
+    void assertCalls(int n) {
+        assertEquals(n, calls.get());
+    }
+
+    @Test
+    public void normal() {
+        Observable.range(1, 10)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v);
+            }
+        })
+        .test()
+        .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    }
+
+    @Test
+    public void normalBackpressured() {
+        Observable.range(1, 10)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v);
+            }
+        })
+        .test(0L)
+        .assertNoValues()
+        .requestMore(1)
+        .assertValues(1)
+        .requestMore(2)
+        .assertValues(1, 2, 3)
+        .requestMore(3)
+        .assertValues(1, 2, 3, 4, 5, 6)
+        .requestMore(4)
+        .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    }
+
+    @Test
+    public void normalMaxConcurrencyBackpressured() {
+        for (int i = 1; i < 16; i++) {
+            Observable.range(1, 10)
+            .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+                @Override
+                public Single<Integer> call(Integer v) {
+                    return Single.just(v);
+                }
+            }, false, i)
+            .test(0L)
+            .assertNoValues()
+            .requestMore(1)
+            .assertValues(1)
+            .requestMore(2)
+            .assertValues(1, 2, 3)
+            .requestMore(3)
+            .assertValues(1, 2, 3, 4, 5, 6)
+            .requestMore(4)
+            .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        }
+    }
+
+    @Test
+    public void normalMaxConcurrent() {
+        for (int i = 1; i < 16; i++) {
+            Observable.range(1, 10)
+            .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+                @Override
+                public Single<Integer> call(Integer v) {
+                    return Single.just(v);
+                }
+            }, false, i)
+            .test()
+            .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        }
+    }
+
+    @Test
+    public void normalMaxConcurrentAsync() {
+        for (int i = 1; i < 2; i++) {
+            AssertableSubscriber<Integer> as = Observable.range(1, 10)
+            .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+                @Override
+                public Single<Integer> call(Integer v) {
+                    return Single.just(v).observeOn(Schedulers.computation());
+                }
+            }, false, i)
+            .test();
+
+            as.awaitTerminalEvent(5, TimeUnit.SECONDS)
+            .assertValueCount(10)
+            .assertNoErrors()
+            .assertCompleted();
+
+            Set<Integer> set = new HashSet<Integer>(as.getOnNextEvents());
+
+            for (int j = 1; j < 11; j++) {
+                assertTrue("" + set, set.contains(j));
+            }
+        }
+    }
+
+    @Test
+    public void justMaxConcurrentAsync() {
+        AssertableSubscriber<Integer> as = Observable.just(1)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v).observeOn(Schedulers.computation());
+            }
+        }, false, 1)
+        .test();
+
+        as.awaitTerminalEvent(5, TimeUnit.SECONDS)
+        .assertResult(1);
+    }
+
+    @Test
+    public void error() {
+        Observable.range(1, 10)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.<Integer>error(new TestException()).doOnError(errorConsumer);
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+
+        assertCalls(1);
+    }
+
+    @Test
+    public void errorDelayed() {
+        AssertableSubscriber<Integer> as = Observable.range(1, 10)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.<Integer>error(new TestException()).doOnError(errorConsumer);
+            }
+        }, true)
+        .test()
+        .assertFailure(CompositeException.class);
+
+        List<Throwable> onErrorEvents = as.getOnErrorEvents();
+
+        assertEquals(onErrorEvents.toString(), 1, onErrorEvents.size());
+
+        onErrorEvents = ((CompositeException)onErrorEvents.get(0)).getExceptions();
+
+        assertEquals(onErrorEvents.toString(), 10, onErrorEvents.size());
+
+        for (Throwable ex : onErrorEvents) {
+            assertTrue(ex.toString(), ex instanceof TestException);
+        }
+
+        assertCalls(10);
+    }
+
+    @Test
+    public void errorDelayedMaxConcurrency() {
+        AssertableSubscriber<Integer> as = Observable.range(1, 10)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.<Integer>error(new TestException()).doOnError(errorConsumer);
+            }
+        }, true, 1)
+        .test()
+        .assertFailure(CompositeException.class);
+
+        List<Throwable> onErrorEvents = as.getOnErrorEvents();
+
+        assertEquals(onErrorEvents.toString(), 1, onErrorEvents.size());
+
+        onErrorEvents = ((CompositeException)onErrorEvents.get(0)).getExceptions();
+
+        assertEquals(onErrorEvents.toString(), 10, onErrorEvents.size());
+
+        for (Throwable ex : onErrorEvents) {
+            assertTrue(ex.toString(), ex instanceof TestException);
+        }
+
+        assertCalls(10);
+    }
+
+    @Test
+    public void mapperThrows() {
+        Observable.range(1, 10)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                throw new TestException();
+            }
+        })
+        .test()
+        .assertFailure(TestException.class);
+    }
+
+    @Test
+    public void mapperNull() {
+        Observable.range(1, 10)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return null;
+            }
+        })
+        .test()
+        .assertFailure(NullPointerException.class);
+    }
+
+    @Test
+    public void paramValidation() {
+        try {
+            Observable.range(1, 10)
+            .flatMapSingle(null);
+            fail("Should have thrown");
+        } catch (NullPointerException ex) {
+            assertEquals("mapper is null", ex.getMessage());
+        }
+
+        try {
+            Observable.range(1, 10)
+            .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+                @Override
+                public Single<Integer> call(Integer v) {
+                    return Single.just(v);
+                }
+            }, false, 0);
+            fail("Should have thrown");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("maxConcurrency > 0 required but it was 0", ex.getMessage());
+        }
+
+        try {
+            Observable.range(1, 10)
+            .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+                @Override
+                public Single<Integer> call(Integer v) {
+                    return Single.just(v);
+                }
+            }, true, -99);
+            fail("Should have thrown");
+        } catch (IllegalArgumentException ex) {
+            assertEquals("maxConcurrency > 0 required but it was -99", ex.getMessage());
+        }
+    }
+
+    @Test
+    public void mainErrorDelayed() {
+        Observable.range(1, 10).concatWith(Observable.<Integer>error(new TestException()))
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v).doOnSuccess(OnSubscribeFlatMapSingleTest.this);
+            }
+        }, true)
+        .test()
+        .assertFailure(TestException.class, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+
+        assertCalls(10);
+    }
+
+    @Test
+    public void mainErrorUnsubscribes() {
+        PublishSubject<Integer> ps0 = PublishSubject.create();
+        final PublishSubject<Integer> ps1 = PublishSubject.create();
+        final PublishSubject<Integer> ps2 = PublishSubject.create();
+
+        TestSubscriber<Integer> as = TestSubscriber.create();
+
+        ps0.flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return v == 0 ? ps1.toSingle() : ps2.toSingle();
+            }
+        }).unsafeSubscribe(as);
+
+        assertTrue(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(0);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(1);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertTrue(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onError(new TestException());
+
+        assertFalse(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertError(TestException.class);
+        as.assertNotCompleted();
+    }
+
+    @Test
+    public void innerErrorUnsubscribes() {
+        PublishSubject<Integer> ps0 = PublishSubject.create();
+        final PublishSubject<Integer> ps1 = PublishSubject.create();
+        final PublishSubject<Integer> ps2 = PublishSubject.create();
+
+        TestSubscriber<Integer> as = TestSubscriber.create();
+
+        ps0.flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return v == 0 ? ps1.toSingle() : ps2.toSingle();
+            }
+        }).unsafeSubscribe(as);
+
+        assertTrue(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(0);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(1);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertTrue(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps1.onError(new TestException());
+
+        assertFalse(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertError(TestException.class);
+        as.assertNotCompleted();
+    }
+
+    @Test
+    public void take() {
+        Observable.range(1, 10)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v);
+            }
+        })
+        .take(5)
+        .test()
+        .assertResult(1, 2, 3, 4, 5);
+    }
+
+
+    @Test
+    public void unsubscribe() {
+        AssertableSubscriber<Integer> as = Observable.range(1, 10)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v);
+            }
+        })
+        .test(0)
+        ;
+
+        as.unsubscribe();
+
+        as.assertNoValues().assertNoErrors().assertNotCompleted();
+    }
+
+    @Test
+    public void mainErrorUnsubscribesNoRequest() {
+        PublishSubject<Integer> ps0 = PublishSubject.create();
+        final PublishSubject<Integer> ps1 = PublishSubject.create();
+        final PublishSubject<Integer> ps2 = PublishSubject.create();
+
+        TestSubscriber<Integer> as = TestSubscriber.create(0L);
+
+        ps0.flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return v == 0 ? ps1.toSingle() : ps2.toSingle();
+            }
+        }).unsafeSubscribe(as);
+
+        assertTrue(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(0);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(1);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertTrue(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onError(new TestException());
+
+        assertFalse(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertError(TestException.class);
+        as.assertNotCompleted();
+    }
+
+    @Test
+    public void innerErrorUnsubscribesNoRequest() {
+        PublishSubject<Integer> ps0 = PublishSubject.create();
+        final PublishSubject<Integer> ps1 = PublishSubject.create();
+        final PublishSubject<Integer> ps2 = PublishSubject.create();
+
+        TestSubscriber<Integer> as = TestSubscriber.create(0L);
+
+        ps0.flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return v == 0 ? ps1.toSingle() : ps2.toSingle();
+            }
+        }).unsafeSubscribe(as);
+
+        assertTrue(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(0);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(1);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertTrue(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps1.onError(new TestException());
+
+        assertFalse(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertError(TestException.class);
+        as.assertNotCompleted();
+    }
+    @Test
+    public void mainErrorUnsubscribesNoRequestDelayError() {
+        PublishSubject<Integer> ps0 = PublishSubject.create();
+        final PublishSubject<Integer> ps1 = PublishSubject.create();
+        final PublishSubject<Integer> ps2 = PublishSubject.create();
+
+        TestSubscriber<Integer> as = TestSubscriber.create(0L);
+
+        ps0.flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return v == 0 ? ps1.toSingle() : ps2.toSingle();
+            }
+        }, true).unsafeSubscribe(as);
+
+        assertTrue(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(0);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(1);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertTrue(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onError(new TestException());
+        ps1.onNext(3);
+        ps1.onCompleted();
+        ps2.onNext(4);
+        ps2.onCompleted();
+
+        assertFalse(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+
+        as.requestMore(2);
+        as.assertValues(3, 4);
+        as.assertError(TestException.class);
+        as.assertNotCompleted();
+    }
+
+    @Test
+    public void innerErrorUnsubscribesNoRequestDelayError() {
+        PublishSubject<Integer> ps0 = PublishSubject.create();
+        final PublishSubject<Integer> ps1 = PublishSubject.create();
+        final PublishSubject<Integer> ps2 = PublishSubject.create();
+
+        TestSubscriber<Integer> as = TestSubscriber.create(0L);
+
+        ps0.flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return v == 0 ? ps1.toSingle() : ps2.toSingle();
+            }
+        }, true).unsafeSubscribe(as);
+
+        assertTrue(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(0);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onNext(1);
+
+        assertTrue(ps0.hasObservers());
+        assertTrue(ps1.hasObservers());
+        assertTrue(ps2.hasObservers());
+        as.assertNoValues();
+        as.assertNoErrors();
+        as.assertNotCompleted();
+
+        ps0.onCompleted();
+        ps1.onError(new TestException());
+        ps2.onNext(4);
+        ps2.onCompleted();
+
+        assertFalse(ps0.hasObservers());
+        assertFalse(ps1.hasObservers());
+        assertFalse(ps2.hasObservers());
+
+        as.requestMore(1);
+        as.assertValues(4);
+        as.assertError(TestException.class);
+        as.assertNotCompleted();
+    }
+
+    @Test
+    public void justBackpressured() {
+        Observable.just(1)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v);
+            }
+        })
+        .test(1L)
+        .assertResult(1);
+    }
+
+    @Test
+    public void justBackpressuredDelayError() {
+        Observable.just(1)
+        .flatMapSingle(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v);
+            }
+        }, true)
+        .test(1L)
+        .assertResult(1);
+    }
+
+    @Test
+    public void singleMerge() {
+        Single.merge(Observable.range(1, 10).map(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v);
+            }
+        }))
+        .test()
+        .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    }
+
+    @Test
+    public void singleMergeMaxConcurrent() {
+        AssertableSubscriber<Integer> as = Single.merge(Observable.range(1, 10).map(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v).observeOn(Schedulers.computation());
+            }
+        }), 2)
+        .test()
+        .awaitTerminalEvent(5, TimeUnit.SECONDS);
+
+        Set<Integer> set = new HashSet<Integer>(as.getOnNextEvents());
+
+        assertEquals("" + set, 10, set.size());
+        for (int j = 1; j < 11; j++) {
+            assertTrue("" + set, set.contains(j));
+        }
+    }
+
+    @Test
+    public void singleMergeDelayError() {
+        Single.mergeDelayError(Observable.range(1, 10).map(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v);
+            }
+        }))
+        .test()
+        .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    }
+
+    @Test
+    public void singleMergeDelayErrorMaxConcurrent() {
+        AssertableSubscriber<Integer> as = Single.mergeDelayError(Observable.range(1, 10).map(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v).observeOn(Schedulers.computation());
+            }
+        }), 2)
+        .test()
+        .awaitTerminalEvent(5, TimeUnit.SECONDS);
+
+        Set<Integer> set = new HashSet<Integer>(as.getOnNextEvents());
+
+        assertEquals("" + set, 10, set.size());
+        for (int j = 1; j < 11; j++) {
+            assertTrue("" + set, set.contains(j));
+        }
+    }
+
+    @Test
+    public void singleMergeDelayErrorWithError() {
+        Single.mergeDelayError(Observable.range(1, 10)
+                .concatWith(Observable.<Integer>error(new TestException()))
+                .map(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v);
+            }
+        }))
+        .test()
+        .assertFailure(TestException.class, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    }
+
+    @Test
+    public void singleMergeDelayMaxConcurrentErrorWithError() {
+        AssertableSubscriber<Integer> as = Single.mergeDelayError(Observable.range(1, 10)
+                .concatWith(Observable.<Integer>error(new TestException()))
+                .map(new Func1<Integer, Single<Integer>>() {
+            @Override
+            public Single<Integer> call(Integer v) {
+                return Single.just(v).observeOn(Schedulers.computation());
+            }
+        }), 2)
+        .test()
+        .awaitTerminalEvent(5, TimeUnit.SECONDS);
+
+        Set<Integer> set = new HashSet<Integer>(as.getOnNextEvents());
+
+        assertEquals("" + set, 10, set.size());
+        for (int j = 1; j < 11; j++) {
+            assertTrue("" + set, set.contains(j));
+        }
+    }
+}

From bc061759f96a03b4810a641208684b40c47a1fca Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 21 Feb 2017 17:45:19 +0100
Subject: [PATCH 220/263] 1.x: reduce stack depth with switchIfEmpty (#5125)

* 1.x: reduce stack depth with switchIfEmpty

* Use source as the indication of first/second phase
---
 src/main/java/rx/Observable.java              |  2 +-
 ...pty.java => OnSubscribeSwitchIfEmpty.java} | 51 +++++++++++++++----
 .../operators/OperatorSwitchIfEmptyTest.java  | 30 +++++++++--
 3 files changed, 69 insertions(+), 14 deletions(-)
 rename src/main/java/rx/internal/operators/{OperatorSwitchIfEmpty.java => OnSubscribeSwitchIfEmpty.java} (70%)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 5978412fc7..6df23ff316 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -5481,7 +5481,7 @@ public final Observable<T> switchIfEmpty(Observable<? extends T> alternate) {
         if (alternate == null) {
             throw new NullPointerException("alternate is null");
         }
-        return lift(new OperatorSwitchIfEmpty<T>(alternate));
+        return unsafeCreate(new OnSubscribeSwitchIfEmpty<T>(this, alternate));
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java b/src/main/java/rx/internal/operators/OnSubscribeSwitchIfEmpty.java
similarity index 70%
rename from src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
rename to src/main/java/rx/internal/operators/OnSubscribeSwitchIfEmpty.java
index f3ead2c604..db02dfbff9 100644
--- a/src/main/java/rx/internal/operators/OperatorSwitchIfEmpty.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeSwitchIfEmpty.java
@@ -16,6 +16,8 @@
 package rx.internal.operators;
 
 
+import java.util.concurrent.atomic.AtomicInteger;
+
 import rx.*;
 import rx.internal.producers.ProducerArbiter;
 import rx.subscriptions.SerialSubscription;
@@ -26,22 +28,28 @@
  * empty, the results of the given Observable will be emitted.
  * @param <T> the value type
  */
-public final class OperatorSwitchIfEmpty<T> implements Observable.Operator<T, T> {
-    private final Observable<? extends T> alternate;
+public final class OnSubscribeSwitchIfEmpty<T> implements Observable.OnSubscribe<T> {
+
+    final Observable<? extends T> source;
 
-    public OperatorSwitchIfEmpty(Observable<? extends T> alternate) {
+    final Observable<? extends T> alternate;
+
+    public OnSubscribeSwitchIfEmpty(Observable<? extends T> source, Observable<? extends T> alternate) {
+        this.source = source;
         this.alternate = alternate;
     }
 
     @Override
-    public Subscriber<? super T> call(Subscriber<? super T> child) {
+    public void call(Subscriber<? super T> child) {
         final SerialSubscription serial = new SerialSubscription();
         ProducerArbiter arbiter = new ProducerArbiter();
         final ParentSubscriber<T> parent = new ParentSubscriber<T>(child, serial, arbiter, alternate);
+
         serial.set(parent);
         child.add(serial);
         child.setProducer(arbiter);
-        return parent;
+
+        parent.subscribe(source);
     }
 
     static final class ParentSubscriber<T> extends Subscriber<T> {
@@ -52,11 +60,15 @@ static final class ParentSubscriber<T> extends Subscriber<T> {
         private final ProducerArbiter arbiter;
         private final Observable<? extends T> alternate;
 
+        final AtomicInteger wip;
+        volatile boolean active;
+
         ParentSubscriber(Subscriber<? super T> child, final SerialSubscription serial, ProducerArbiter arbiter, Observable<? extends T> alternate) {
             this.child = child;
             this.serial = serial;
             this.arbiter = arbiter;
             this.alternate = alternate;
+            this.wip = new AtomicInteger();
         }
 
         @Override
@@ -69,14 +81,33 @@ public void onCompleted() {
             if (!empty) {
                 child.onCompleted();
             } else if (!child.isUnsubscribed()) {
-                subscribeToAlternate();
+                active = false;
+                subscribe(null);
             }
         }
 
-        private void subscribeToAlternate() {
-            AlternateSubscriber<T> as = new AlternateSubscriber<T>(child, arbiter);
-            serial.set(as);
-            alternate.unsafeSubscribe(as);
+        void subscribe(Observable<? extends T> source) {
+            if (wip.getAndIncrement() == 0) {
+                do {
+                    if (child.isUnsubscribed()) {
+                        break;
+                    }
+
+                    if (!active) {
+                        if (source == null) {
+                            AlternateSubscriber<T> as = new AlternateSubscriber<T>(child, arbiter);
+                            serial.set(as);
+                            active = true;
+                            alternate.unsafeSubscribe(as);
+                        } else {
+                            active = true;
+                            source.unsafeSubscribe(this);
+                            source = null;
+                        }
+                    }
+
+                } while (wip.decrementAndGet() != 0);
+            }
         }
 
         @Override
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java b/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
index 5108f4001d..235cac495b 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchIfEmptyTest.java
@@ -17,16 +17,15 @@
 
 import static org.junit.Assert.*;
 
-import java.util.*;
+import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 
 import rx.*;
-import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.functions.Action0;
+import rx.functions.*;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
@@ -212,4 +211,29 @@ public void call() {
     public void testAlternateNull() {
         Observable.just(1).switchIfEmpty(null);
     }
+
+    Observable<StackTraceElement[]> recursiveSwitch(final int level) {
+        if (level == 100) {
+            return Observable.just(Thread.currentThread().getStackTrace());
+        }
+        return Observable.<StackTraceElement[]>empty().switchIfEmpty(Observable.defer(new Func0<Observable<StackTraceElement[]>>() {
+            @Override
+            public Observable<StackTraceElement[]> call() {
+                return recursiveSwitch(level + 1);
+            }
+        }));
+    }
+
+    @Test
+    public void stackDepth() {
+        StackTraceElement[] trace = recursiveSwitch(0)
+        .toBlocking().last();
+
+        if (trace.length > 1000 || trace.length < 100) {
+            for (StackTraceElement ste : trace) {
+                System.out.println(ste);
+            }
+            fail("Stack too deep: " + trace.length);
+        }
+    }
 }
\ No newline at end of file

From e8b603535cd3f7a4bdbca6ba38d9d0c53c99e67a Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 22 Feb 2017 10:59:43 +0100
Subject: [PATCH 221/263] 1.x: throttleFirst detecting clock-drift backwards to
 open the gate (#5123)

---
 .../operators/OperatorThrottleFirst.java      |  2 +-
 .../operators/OperatorThrottleFirstTest.java  | 40 +++++++++++++------
 2 files changed, 29 insertions(+), 13 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorThrottleFirst.java b/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
index fbd3c64d7d..f9093efa39 100644
--- a/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
+++ b/src/main/java/rx/internal/operators/OperatorThrottleFirst.java
@@ -48,7 +48,7 @@ public void onStart() {
             @Override
             public void onNext(T v) {
                 long now = scheduler.now();
-                if (lastOnNext == -1 || now - lastOnNext >= timeInMilliseconds) {
+                if (lastOnNext == -1 || now < lastOnNext || now - lastOnNext >= timeInMilliseconds) {
                     lastOnNext = now;
                     subscriber.onNext(v);
                 }
diff --git a/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java b/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
index 4908efc534..f0fc6527a6 100644
--- a/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
+++ b/src/test/java/rx/internal/operators/OperatorThrottleFirstTest.java
@@ -16,26 +16,18 @@
 package rx.internal.operators;
 
 import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.*;
 
 import java.util.concurrent.TimeUnit;
 
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.*;
 import org.mockito.InOrder;
 
-import rx.Observable;
+import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Subscriber;
 import rx.exceptions.TestException;
 import rx.functions.Action0;
-import rx.observers.TestSubscriber;
+import rx.observers.*;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -214,4 +206,28 @@ public void throttleWithTestSchedulerTimeOfZero() {
         verify(observer).onCompleted();
         verifyNoMoreInteractions(observer);
     }
+
+    @Test
+    public void nowDrift() {
+        TestScheduler s = new TestScheduler();
+        s.advanceTimeBy(2, TimeUnit.SECONDS);
+
+        PublishSubject<Integer> o = PublishSubject.create();
+
+        AssertableSubscriber<Integer> as = o.throttleFirst(500, TimeUnit.MILLISECONDS, s)
+        .test();
+
+        o.onNext(1);
+        s.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+        o.onNext(2);
+        s.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+        o.onNext(3);
+        s.advanceTimeBy(-1000, TimeUnit.MILLISECONDS);
+        o.onNext(4);
+        s.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+        o.onNext(5);
+        o.onCompleted();
+
+        as.assertResult(1, 4);
+    }
 }

From ccc2b2cdf4289238af2352d37339db52936e9841 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 24 Feb 2017 09:31:17 +0100
Subject: [PATCH 222/263] Release 1.2.7

---
 CHANGES.md | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index c20f538c36..f47d459578 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,40 @@
 # RxJava Releases #
 
+### Version 1.2.7 - February 24, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.7%7C))
+
+#### Deprecation of `create(OnSubscribe)`
+
+The method started out in RxJava 0.x as a simple and direct way for implementing custom operators because 0.x had a much simpler protocol requirements. Over the years, as the `Observable` protocol evolved and `create` became a powerful and complicated extension point of RxJava that required users to implement the `Observable` protocol, including cancellation and backpressure manually.
+
+Unfortunately, guides, blogs, StackOverflow answers and mere typical user behavior still leads to this `create` method and lots of confusion, unstoppable sequences and `MissingBackpressureException`. We tried remedying the situation by introducing `fromEmitter` with limited discoverability success.
+
+**Therefore, as of 1.2.7 the `create()` method is now deprecated** (but won't be removed due to binary compatibility requirements). In addition `fromEmitter` has been deprecate-renamed to `create(Action1, BackpressureMode)` and the experimental-marked `fromEmitter` itself will be removed in 1.3.0.
+
+Since the functionality of `create()` was useful for writing (custom) operators inside and outside of RxJava, the new `unsafeCreate(OnSubscribe)` method was introduced as the replacement.
+
+The new `create()` and `unsafeCreate()` methods will be fast-tracked to become standard in 1.3.0.
+
+#### API enhancements
+
+- [Pull 5086](https://github.com/ReactiveX/RxJava/pull/5086): Deprecate `create()`, add alternatives
+- [Pull 5092](https://github.com/ReactiveX/RxJava/pull/5092): Add `Single.merge(Observable<Single<T>>)`, `Observable.flatMapSingle()` & `Observable.flatMapCompletable`.
+- [Pull 5091](https://github.com/ReactiveX/RxJava/pull/5091): Add `subscribeOn(Scheduler, boolean)` avoid same-pool deadlock.
+
+#### API deprecations
+
+- [Pull 5086](https://github.com/ReactiveX/RxJava/pull/5086): 
+  - Deprecate `Observable.create(OnSubscribe)`, 
+  - Deprecate `fromEmitter` in favor of `Observable.create(Action1, BackpressureMode)`. 
+
+#### Bugfixes
+
+- [Pull 5091](https://github.com/ReactiveX/RxJava/pull/5091): `create(Action1, BackpressureMode)`+`subscribeOn` avoid same-pool deadlock.
+- [Pull 5123](https://github.com/ReactiveX/RxJava/pull/5123): `throttleFirst` detecting clock-drift backwards to open the gate
+
+#### Other
+
+- [Pull 5125](https://github.com/ReactiveX/RxJava/pull/5125): reduce stack depth with `switchIfEmpty`
+
 ### Version 1.2.6 - February 3, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.6%7C))
 
 #### Documentation

From 2a0427b895f523b3ccdd7bc58eeef3a0b2e3c322 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Mon, 27 Feb 2017 19:25:53 +0100
Subject: [PATCH 223/263] 1.x: fix timed replay() not terminating when all
 items timeout (#5141)

---
 .../rx/internal/operators/OperatorReplay.java  | 15 ++++++++++++---
 .../internal/operators/OperatorReplayTest.java | 16 ++++++++++++++++
 .../java/rx/subjects/ReplaySubjectTest.java    | 18 ++++++++++++++++++
 3 files changed, 46 insertions(+), 3 deletions(-)

diff --git a/src/main/java/rx/internal/operators/OperatorReplay.java b/src/main/java/rx/internal/operators/OperatorReplay.java
index 045eae96af..a89ac32bd7 100644
--- a/src/main/java/rx/internal/operators/OperatorReplay.java
+++ b/src/main/java/rx/internal/operators/OperatorReplay.java
@@ -1239,9 +1239,18 @@ Node getInitialHead() {
             Node prev = get();
 
             Node next = prev.get();
-            while (next != null && ((Timestamped<?>)next.value).getTimestampMillis() <= timeLimit) {
-                prev = next;
-                next = next.get();
+            while (next != null) {
+                Object o = next.value;
+                Object v = leaveTransform(o);
+                if (NotificationLite.isCompleted(v) || NotificationLite.isError(v)) {
+                    break;
+                }
+                if (((Timestamped<?>)o).getTimestampMillis() <= timeLimit) {
+                    prev = next;
+                    next = next.get();
+                } else {
+                    break;
+                }
             }
 
             return prev;
diff --git a/src/test/java/rx/internal/operators/OperatorReplayTest.java b/src/test/java/rx/internal/operators/OperatorReplayTest.java
index e4734c30a6..999e343b8e 100644
--- a/src/test/java/rx/internal/operators/OperatorReplayTest.java
+++ b/src/test/java/rx/internal/operators/OperatorReplayTest.java
@@ -1577,4 +1577,20 @@ public ConnectableObservable<Integer> call(Observable<Integer> o) {
         });
     }
 
+    @Test
+    public void noOldEntries() {
+        TestScheduler scheduler = new TestScheduler();
+
+        Observable<Integer> source = Observable.just(1)
+        .replay(2, TimeUnit.SECONDS, scheduler)
+        .autoConnect();
+        
+        source.test().assertResult(1);
+
+        source.test().assertResult(1);
+
+        scheduler.advanceTimeBy(3, TimeUnit.SECONDS);
+
+        source.test().assertResult();
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/rx/subjects/ReplaySubjectTest.java b/src/test/java/rx/subjects/ReplaySubjectTest.java
index 8464cf1b3f..dc624367f3 100644
--- a/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -1175,4 +1175,22 @@ public Boolean call(Integer v) {
         ts2.assertValues(1, 2, 3, 6, 7);
     }
 
+    @Test
+    public void noOldEntries() {
+        TestScheduler scheduler = new TestScheduler();
+
+        ReplaySubject<Integer> source = ReplaySubject.createWithTime(2, TimeUnit.SECONDS, scheduler);
+
+        source.onNext(1);
+        source.onCompleted();
+        
+        source.test().assertResult(1);
+
+        source.test().assertResult(1);
+
+        scheduler.advanceTimeBy(3, TimeUnit.SECONDS);
+
+        source.test().assertResult();
+    }
+
 }

From c8e22d87e0f1f68cc12af5def0f821e07c2d54c8 Mon Sep 17 00:00:00 2001
From: Yasuhiro Shimizu <the.phantom.bane@gmail.com>
Date: Sun, 12 Mar 2017 20:53:46 +0900
Subject: [PATCH 224/263] add unsubscribeOn to Single type (#5138) (#5146)

---
 src/main/java/rx/Single.java     | 44 +++++++++++++++++++++++
 src/test/java/rx/SingleTest.java | 62 ++++++++++++++++++++++++++++++++
 2 files changed, 106 insertions(+)

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index a1614137f6..a92c2a9caa 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -2808,6 +2808,50 @@ public final Single<T> delaySubscription(Observable<?> other) {
         return create(new SingleOnSubscribeDelaySubscriptionOther<T>(this, other));
     }
 
+    /**
+     * Returns a Single which makes sure when a subscriber cancels the subscription,
+     * the dispose is called on the specified scheduler
+     * @param scheduler the target scheduler where to execute the cancellation
+     * @return the new Single instance
+     */
+    public final Single<T> unsubscribeOn(final Scheduler scheduler) {
+        return create(new OnSubscribe<T>() {
+            @Override
+            public void call(final SingleSubscriber<? super T> t) {
+                final SingleSubscriber<T> single = new SingleSubscriber<T>() {
+                    @Override
+                    public void onSuccess(T value) {
+                        t.onSuccess(value);
+                    }
+
+                    @Override
+                    public void onError(Throwable error) {
+                        t.onError(error);
+                    }
+                };
+
+                t.add(Subscriptions.create(new Action0() {
+                    @Override
+                    public void call() {
+                        final Scheduler.Worker w = scheduler.createWorker();
+                        w.schedule(new Action0() {
+                            @Override
+                            public void call() {
+                                try {
+                                    single.unsubscribe();
+                                } finally {
+                                    w.unsubscribe();
+                                }
+                            }
+                        });
+                    }
+                }));
+
+                Single.this.subscribe(single);
+            }
+        });
+    }
+
     // -------------------------------------------------------------------------
     // Fluent test support, super handy and reduces test preparation boilerplate
     // -------------------------------------------------------------------------
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index eefcde2699..f07e6d9216 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -28,6 +28,7 @@
 import rx.Single.OnSubscribe;
 import rx.exceptions.*;
 import rx.functions.*;
+import rx.internal.util.RxThreadFactory;
 import rx.observers.*;
 import rx.plugins.RxJavaHooks;
 import rx.schedulers.*;
@@ -2230,4 +2231,65 @@ public void call(Throwable t) {
 
         assertEquals(1, calls[0]);
     }
+
+    @Test
+    public void unsubscribeOnSuccess() throws InterruptedException {
+        final AtomicReference<String> name = new AtomicReference<String>();
+
+        final CountDownLatch cdl = new CountDownLatch(1);
+
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+
+        Single.fromCallable(new Callable<Integer>() {
+            @Override
+            public Integer call() throws Exception {
+                return 1;
+            }
+        })
+                .doOnUnsubscribe(new Action0() {
+                    @Override
+                    public void call() {
+                        name.set(Thread.currentThread().getName());
+                        cdl.countDown();
+                    }
+                })
+                .subscribeOn(Schedulers.io())
+                .unsubscribeOn(Schedulers.computation())
+                .subscribe(ts);
+
+        cdl.await();
+
+        ts.awaitTerminalEvent();
+        ts.assertReceivedOnNext(Arrays.asList(1));
+
+        assertTrue(name.get().startsWith("RxComputation"));
+    }
+
+    @Test
+    public void unsubscribeOnError() throws InterruptedException {
+        final AtomicReference<String> name = new AtomicReference<String>();
+
+        final CountDownLatch cdl = new CountDownLatch(1);
+
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+
+        Single.<Integer>error(new RuntimeException())
+                .doOnUnsubscribe(new Action0() {
+                    @Override
+                    public void call() {
+                        name.set(Thread.currentThread().getName());
+                        cdl.countDown();
+                    }
+                })
+                .subscribeOn(Schedulers.io())
+                .unsubscribeOn(Schedulers.computation())
+                .subscribe(ts);
+
+        cdl.await();
+
+        ts.awaitTerminalEvent();
+        ts.assertError(RuntimeException.class);
+
+        assertTrue(name.get().startsWith("RxComputation"));
+    }
 }

From 881183178e5f0d163052a4dd86569fbac1fb8bf1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?D=C3=A1vid=20Karnok?= <akarnokd@gmail.com>
Date: Sun, 12 Mar 2017 12:56:22 +0100
Subject: [PATCH 225/263] 1.x add missing @Experimental tag to unsubscribeOn

---
 src/main/java/rx/Single.java                                | 2 ++
 src/test/java/rx/SingleTest.java                            | 1 -
 src/test/java/rx/internal/operators/OperatorReplayTest.java | 2 +-
 src/test/java/rx/subjects/ReplaySubjectTest.java            | 2 +-
 4 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index a92c2a9caa..6edb80ab15 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -2813,7 +2813,9 @@ public final Single<T> delaySubscription(Observable<?> other) {
      * the dispose is called on the specified scheduler
      * @param scheduler the target scheduler where to execute the cancellation
      * @return the new Single instance
+     * @since 1.2.8 - experimental
      */
+    @Experimental
     public final Single<T> unsubscribeOn(final Scheduler scheduler) {
         return create(new OnSubscribe<T>() {
             @Override
diff --git a/src/test/java/rx/SingleTest.java b/src/test/java/rx/SingleTest.java
index f07e6d9216..9ae7fa0f90 100644
--- a/src/test/java/rx/SingleTest.java
+++ b/src/test/java/rx/SingleTest.java
@@ -28,7 +28,6 @@
 import rx.Single.OnSubscribe;
 import rx.exceptions.*;
 import rx.functions.*;
-import rx.internal.util.RxThreadFactory;
 import rx.observers.*;
 import rx.plugins.RxJavaHooks;
 import rx.schedulers.*;
diff --git a/src/test/java/rx/internal/operators/OperatorReplayTest.java b/src/test/java/rx/internal/operators/OperatorReplayTest.java
index 999e343b8e..fbe256ef01 100644
--- a/src/test/java/rx/internal/operators/OperatorReplayTest.java
+++ b/src/test/java/rx/internal/operators/OperatorReplayTest.java
@@ -1584,7 +1584,7 @@ public void noOldEntries() {
         Observable<Integer> source = Observable.just(1)
         .replay(2, TimeUnit.SECONDS, scheduler)
         .autoConnect();
-        
+
         source.test().assertResult(1);
 
         source.test().assertResult(1);
diff --git a/src/test/java/rx/subjects/ReplaySubjectTest.java b/src/test/java/rx/subjects/ReplaySubjectTest.java
index dc624367f3..63b63ea16c 100644
--- a/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -1183,7 +1183,7 @@ public void noOldEntries() {
 
         source.onNext(1);
         source.onCompleted();
-        
+
         source.test().assertResult(1);
 
         source.test().assertResult(1);

From 0f1542d7d5d2ce2e89118a5701a6d6fd7d5684b0 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 15 Mar 2017 17:31:08 +0100
Subject: [PATCH 226/263] 1.x: replay().refCount() avoid leaking items between
 connections (#5181)

* 1.x: replay().refCount() avoid leaking items between connections

* Improve coverage of changes.
---
 .../operators/OnSubscribeRefCount.java        |  12 ++
 .../rx/internal/operators/OperatorReplay.java |  13 +-
 .../operators/OnSubscribeRefCountTest.java    | 153 ++++++++++++++++++
 3 files changed, 177 insertions(+), 1 deletion(-)

diff --git a/src/main/java/rx/internal/operators/OnSubscribeRefCount.java b/src/main/java/rx/internal/operators/OnSubscribeRefCount.java
index c5898ac1b6..4a34663fbb 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeRefCount.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeRefCount.java
@@ -129,7 +129,13 @@ void cleanup() {
                 // and set the subscriptionCount to 0
                 lock.lock();
                 try {
+
                     if (baseSubscription == currentBase) {
+                        // backdoor into the ConnectableObservable to cleanup and reset its state
+                        if (source instanceof Subscription) {
+                            ((Subscription)source).unsubscribe();
+                        }
+
                         baseSubscription.unsubscribe();
                         baseSubscription = new CompositeSubscription();
                         subscriptionCount.set(0);
@@ -148,7 +154,13 @@ public void call() {
                 lock.lock();
                 try {
                     if (baseSubscription == current) {
+
                         if (subscriptionCount.decrementAndGet() == 0) {
+                            // backdoor into the ConnectableObservable to cleanup and reset its state
+                            if (source instanceof Subscription) {
+                                ((Subscription)source).unsubscribe();
+                            }
+
                             baseSubscription.unsubscribe();
                             // need a new baseSubscription because once
                             // unsubscribed stays that way
diff --git a/src/main/java/rx/internal/operators/OperatorReplay.java b/src/main/java/rx/internal/operators/OperatorReplay.java
index a89ac32bd7..6447b2c737 100644
--- a/src/main/java/rx/internal/operators/OperatorReplay.java
+++ b/src/main/java/rx/internal/operators/OperatorReplay.java
@@ -28,7 +28,7 @@
 import rx.schedulers.Timestamped;
 import rx.subscriptions.Subscriptions;
 
-public final class OperatorReplay<T> extends ConnectableObservable<T> {
+public final class OperatorReplay<T> extends ConnectableObservable<T> implements Subscription {
     /** The source observable. */
     final Observable<? extends T> source;
     /** Holds the current subscriber that is, will be or just was subscribed to the source observable. */
@@ -254,6 +254,17 @@ private OperatorReplay(OnSubscribe<T> onSubscribe, Observable<? extends T> sourc
         this.bufferFactory = bufferFactory;
     }
 
+    @Override
+    public void unsubscribe() {
+        current.lazySet(null);
+    }
+
+    @Override
+    public boolean isUnsubscribed() {
+        ReplaySubscriber<T> ps = current.get();
+        return ps == null || ps.isUnsubscribed();
+    }
+
     @Override
     public void connect(Action1<? super Subscription> connection) {
         boolean doConnect;
diff --git a/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java b/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java
index a64f808e78..a824f3191b 100644
--- a/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java
+++ b/src/test/java/rx/internal/operators/OnSubscribeRefCountTest.java
@@ -19,6 +19,7 @@
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.*;
 
+import java.lang.management.ManagementFactory;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
@@ -31,6 +32,7 @@
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.functions.*;
+import rx.observables.ConnectableObservable;
 import rx.observers.*;
 import rx.schedulers.*;
 import rx.subjects.ReplaySubject;
@@ -611,4 +613,155 @@ public void call(Throwable t) {
         assertNotNull("First subscriber didn't get the error", err1);
         assertNotNull("Second subscriber didn't get the error", err2);
     }
+
+    Observable<Object> source;
+
+    @Test
+    public void replayNoLeak() throws Exception {
+        System.gc();
+        Thread.sleep(100);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Observable.fromCallable(new Callable<Object>() {
+            @Override
+            public Object call() throws Exception {
+                return new byte[100 * 1000 * 1000];
+            }
+        })
+        .replay(1)
+        .refCount();
+
+        source.subscribe();
+
+        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 {
+        System.gc();
+        Thread.sleep(100);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Observable.fromCallable(new Callable<Object>() {
+            @Override
+            public Object call() throws Exception {
+                return new byte[100 * 1000 * 1000];
+            }
+        }).concatWith(Observable.never())
+        .replay(1)
+        .refCount();
+
+        Subscription s1 = source.subscribe();
+        Subscription s2 = source.subscribe();
+
+        s1.unsubscribe();
+        s2.unsubscribe();
+
+        s1 = null;
+        s2 = 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);
+    }
+
+    static final class ExceptionData extends Exception {
+        private static final long serialVersionUID = -6763898015338136119L;
+
+        public final Object data;
+
+        public ExceptionData(Object data) {
+            this.data = data;
+        }
+    }
+
+    @Test
+    public void publishNoLeak() throws Exception {
+        System.gc();
+        Thread.sleep(100);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Observable.fromCallable(new Callable<Object>() {
+            @Override
+            public Object call() throws Exception {
+                throw new ExceptionData(new byte[100 * 1000 * 1000]);
+            }
+        })
+        .publish()
+        .refCount();
+
+        Action1<Throwable> err = Actions.empty();
+        source.subscribe(Actions.empty(), err);
+
+        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 publishNoLeak2() throws Exception {
+        System.gc();
+        Thread.sleep(100);
+
+        long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
+
+        source = Observable.fromCallable(new Callable<Object>() {
+            @Override
+            public Object call() throws Exception {
+                return new byte[100 * 1000 * 1000];
+            }
+        }).concatWith(Observable.never())
+        .publish()
+        .refCount();
+
+        Subscription s1 = source.test(0);
+        Subscription s2 = source.test(0);
+
+        s1.unsubscribe();
+        s2.unsubscribe();
+
+        s1 = null;
+        s2 = 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() {
+        ConnectableObservable<Integer> co = Observable.just(1)
+        .replay();
+
+        assertTrue(((Subscription)co).isUnsubscribed());
+
+        Subscription s = co.connect();
+
+        assertFalse(((Subscription)co).isUnsubscribed());
+
+        s.unsubscribe();
+
+        assertTrue(((Subscription)co).isUnsubscribed());
+    }
 }

From e6824c1ab2b649654bebabc3cedb5a15f7605141 Mon Sep 17 00:00:00 2001
From: Maksym Ostroverkhov <mostroverkhov@users.noreply.github.com>
Date: Sat, 18 Mar 2017 18:47:14 +0200
Subject: [PATCH 227/263] 1.X: UnicastSubject fail-fast and delay-error
 behavior (#5195)

* 1.X: unicastSubject does not replay onNext calls made prior to subscription if onError is also called prior to subscription.

* cache delayError field in local variable
---
 src/main/java/rx/subjects/UnicastSubject.java |  62 +++++++++--
 .../java/rx/subjects/UnicastSubjectTest.java  | 101 ++++++++++++++++++
 2 files changed, 153 insertions(+), 10 deletions(-)
 create mode 100644 src/test/java/rx/subjects/UnicastSubjectTest.java

diff --git a/src/main/java/rx/subjects/UnicastSubject.java b/src/main/java/rx/subjects/UnicastSubject.java
index c1c69f9e36..74bdf3d539 100644
--- a/src/main/java/rx/subjects/UnicastSubject.java
+++ b/src/main/java/rx/subjects/UnicastSubject.java
@@ -49,6 +49,7 @@ public final class UnicastSubject<T> extends Subject<T, T> {
     public static <T> UnicastSubject<T> create() {
         return create(16);
     }
+
     /**
      * Constructs an empty UnicastSubject instance with a capacity hint.
      * <p>The capacity hint determines the internal queue's island size: the larger
@@ -59,7 +60,18 @@ public static <T> UnicastSubject<T> create() {
      * @return the created BufferUntilSubscriber instance
      */
     public static <T> UnicastSubject<T> create(int capacityHint) {
-        State<T> state = new State<T>(capacityHint, null);
+        State<T> state = new State<T>(capacityHint, false, null);
+        return new UnicastSubject<T>(state);
+    }
+
+    /**
+     * Constructs an empty UnicastSubject instance with the default capacity hint of 16 elements.
+     *
+     * @param delayError deliver pending next events before error.
+     * @return the created UnicastSubject instance
+     */
+    public static <T> UnicastSubject<T> create(boolean delayError) {
+        State<T> state = new State<T>(16, delayError, null);
         return new UnicastSubject<T>(state);
     }
 
@@ -78,7 +90,28 @@ public static <T> UnicastSubject<T> create(int capacityHint) {
      * @return the created BufferUntilSubscriber instance
      */
     public static <T> UnicastSubject<T> create(int capacityHint, Action0 onTerminated) {
-        State<T> state = new State<T>(capacityHint, onTerminated);
+        State<T> state = new State<T>(capacityHint, false, onTerminated);
+        return new UnicastSubject<T>(state);
+    }
+
+    /**
+     * Constructs an empty UnicastSubject instance with a capacity hint, delay error
+     * flag and Action0 instance to call if the subject reaches its terminal state
+     * or the single Subscriber unsubscribes mid-sequence.
+     * <p>The capacity hint determines the internal queue's island size: the larger
+     * it is the less frequent allocation will happen if there is no subscriber
+     * or the subscriber hasn't caught up.
+     * @param <T> the input and output value type
+     * @param capacityHint the capacity hint for the internal queue
+     * @param onTerminated the optional callback to call when subject reaches its terminal state
+     *                      or the single Subscriber unsubscribes mid-sequence. It will be called
+     *                      at most once.
+     * @param delayError flag indicating whether to deliver pending next events before error.
+     * @return the created BufferUntilSubscriber instance
+     */
+    public static <T> UnicastSubject<T> create(int capacityHint,
+                                               Action0 onTerminated, boolean delayError) {
+        State<T> state = new State<T>(capacityHint, delayError, onTerminated);
         return new UnicastSubject<T>(state);
     }
 
@@ -119,6 +152,8 @@ static final class State<T> extends AtomicLong implements Producer, Observer<T>,
         final AtomicReference<Subscriber<? super T>> subscriber;
         /** The queue holding values until the subscriber arrives and catches up. */
         final Queue<Object> queue;
+        /** Deliver pending next events before error. */
+        final boolean delayError;
         /** Atomically set to true on terminal condition. */
         final AtomicReference<Action0> terminateOnce;
         /** In case the source emitted an error. */
@@ -137,10 +172,12 @@ static final class State<T> extends AtomicLong implements Producer, Observer<T>,
          * reduce allocation frequency
          * @param onTerminated the action to call when the subject reaches its terminal state or
          * the single subscriber unsubscribes.
+         * @param delayError deliver pending next events before error.
          */
-        public State(int capacityHint, Action0 onTerminated) {
+        public State(int capacityHint, boolean delayError, Action0 onTerminated) {
             this.subscriber = new AtomicReference<Subscriber<? super T>>();
             this.terminateOnce = onTerminated != null ? new AtomicReference<Action0>(onTerminated) : null;
+            this.delayError = delayError;
 
             Queue<Object> q;
             if (capacityHint > 1) {
@@ -266,14 +303,14 @@ void replay() {
                 emitting = true;
             }
             Queue<Object> q = queue;
+            boolean delayError = this.delayError;
             for (;;) {
                 Subscriber<? super T> s = subscriber.get();
                 boolean unlimited = false;
                 if (s != null) {
                     boolean d = done;
                     boolean empty = q.isEmpty();
-
-                    if (checkTerminated(d, empty, s)) {
+                    if (checkTerminated(d, empty, delayError, s)) {
                         return;
                     }
                     long r = get();
@@ -284,7 +321,7 @@ void replay() {
                         d = done;
                         Object v = q.poll();
                         empty = v == null;
-                        if (checkTerminated(d, empty, s)) {
+                        if (checkTerminated(d, empty, delayError, s)) {
                             return;
                         }
                         if (empty) {
@@ -348,23 +385,28 @@ public boolean isUnsubscribed() {
          * an error happened or the source terminated and the queue is empty
          * @param done indicates the source has called onCompleted
          * @param empty indicates if there are no more source values in the queue
+         * @param delayError indicates whether to deliver pending next events before error
          * @param s the target Subscriber to emit events to
          * @return true if this Subject reached a terminal state and the drain loop should quit
          */
-        boolean checkTerminated(boolean done, boolean empty, Subscriber<? super T> s) {
+        boolean checkTerminated(boolean done, boolean empty, boolean delayError, Subscriber<? super T> s) {
             if (s.isUnsubscribed()) {
                 queue.clear();
                 return true;
             }
             if (done) {
                 Throwable e = error;
-                if (e != null) {
+                if (e != null && !delayError) {
                     queue.clear();
                     s.onError(e);
                     return true;
-                } else
+                }
                 if (empty) {
-                    s.onCompleted();
+                    if (e != null) {
+                        s.onError(e);
+                    } else {
+                        s.onCompleted();
+                    }
                     return true;
                 }
             }
diff --git a/src/test/java/rx/subjects/UnicastSubjectTest.java b/src/test/java/rx/subjects/UnicastSubjectTest.java
new file mode 100644
index 0000000000..af9ef33468
--- /dev/null
+++ b/src/test/java/rx/subjects/UnicastSubjectTest.java
@@ -0,0 +1,101 @@
+package rx.subjects;
+
+import org.junit.Test;
+import rx.functions.Action0;
+import rx.observers.TestSubscriber;
+
+public class UnicastSubjectTest {
+
+    @Test
+    public void testOneArgFactoryDelayError() throws Exception {
+        TestSubscriber<Long> subscriber = TestSubscriber.<Long>create();
+        UnicastSubject<Long> s = UnicastSubject.create(true);
+        s.onNext(1L);
+        s.onNext(2L);
+        s.onError(new RuntimeException());
+        s.subscribe(subscriber);
+        subscriber.assertValueCount(2);
+        subscriber.assertError(RuntimeException.class);
+    }
+
+    @Test
+    public void testOneArgFactoryNoDelayError() throws Exception {
+        TestSubscriber<Long> subscriber = TestSubscriber.<Long>create();
+        UnicastSubject<Long> s = UnicastSubject.create(false);
+        s.onNext(1L);
+        s.onNext(2L);
+        s.onError(new RuntimeException());
+        s.subscribe(subscriber);
+        subscriber.assertValueCount(0);
+        subscriber.assertError(RuntimeException.class);
+    }
+
+    @Test
+    public void testThreeArgsFactoryDelayError() throws Exception {
+        TestSubscriber<Long> subscriber = TestSubscriber.<Long>create();
+        UnicastSubject<Long> s = UnicastSubject.create(16, new NoopAction0(), true);
+        s.onNext(1L);
+        s.onNext(2L);
+        s.onError(new RuntimeException());
+        s.subscribe(subscriber);
+        subscriber.assertValueCount(2);
+        subscriber.assertError(RuntimeException.class);
+    }
+
+    @Test
+    public void testThreeArgsFactoryNoDelayError() throws Exception {
+        TestSubscriber<Long> subscriber = TestSubscriber.<Long>create();
+        UnicastSubject<Long> s = UnicastSubject.create(16, new NoopAction0(), false);
+        s.onNext(1L);
+        s.onNext(2L);
+        s.onError(new RuntimeException());
+        s.subscribe(subscriber);
+        subscriber.assertValueCount(0);
+        subscriber.assertError(RuntimeException.class);
+    }
+
+    @Test
+    public void testZeroArgsFactory() throws Exception {
+        TestSubscriber<Long> subscriber = TestSubscriber.<Long>create();
+        UnicastSubject<Long> s = UnicastSubject.create();
+        s.onNext(1L);
+        s.onNext(2L);
+        s.onError(new RuntimeException());
+        s.subscribe(subscriber);
+        subscriber.assertValueCount(0);
+        subscriber.assertError(RuntimeException.class);
+    }
+
+    @Test
+    public void testOneArgFactory() throws Exception {
+        TestSubscriber<Long> subscriber = TestSubscriber.<Long>create();
+        UnicastSubject<Long> s = UnicastSubject.create(16);
+        s.onNext(1L);
+        s.onNext(2L);
+        s.onError(new RuntimeException());
+        s.subscribe(subscriber);
+        subscriber.assertValueCount(0);
+        subscriber.assertError(RuntimeException.class);
+    }
+
+    @Test
+    public void testTwoArgsFactory() throws Exception {
+        TestSubscriber<Long> subscriber = TestSubscriber.<Long>create();
+        UnicastSubject<Long> s = UnicastSubject.create(16, new NoopAction0());
+        s.onNext(1L);
+        s.onNext(2L);
+        s.onError(new RuntimeException());
+        s.subscribe(subscriber);
+        subscriber.assertValueCount(0);
+        subscriber.assertError(RuntimeException.class);
+    }
+
+
+
+    private static final class NoopAction0 implements Action0 {
+
+        @Override
+        public void call() {
+        }
+    }
+}

From d1f20a16c50600097130a60ee7e710a7e7453607 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 21 Mar 2017 23:14:01 +0100
Subject: [PATCH 228/263] 1.x: add marble diagram to UnicastSubject, fix
 javadoc (#5209)

---
 src/main/java/rx/subjects/UnicastSubject.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/main/java/rx/subjects/UnicastSubject.java b/src/main/java/rx/subjects/UnicastSubject.java
index 74bdf3d539..1c51fe48bb 100644
--- a/src/main/java/rx/subjects/UnicastSubject.java
+++ b/src/main/java/rx/subjects/UnicastSubject.java
@@ -32,7 +32,8 @@
  * amount. In this case, the buffered values are no longer retained. If the Subscriber
  * requests a limited amount, queueing is involved and only those values are retained which
  * weren't requested by the Subscriber at that time.
- *
+ * <p>
+ * <img width="640" height="370" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/UnicastSubject.v1.png" alt="">
  * @param <T> the input and output value type
  */
 @Experimental
@@ -68,6 +69,7 @@ public static <T> UnicastSubject<T> create(int capacityHint) {
      * Constructs an empty UnicastSubject instance with the default capacity hint of 16 elements.
      *
      * @param delayError deliver pending next events before error.
+     * @param <T> the input and output value type
      * @return the created UnicastSubject instance
      */
     public static <T> UnicastSubject<T> create(boolean delayError) {

From 72a6dee2d2b15b05d8448f83dfab98ab3d6c900f Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 24 Mar 2017 09:31:33 +0100
Subject: [PATCH 229/263] Release 1.2.8

---
 CHANGES.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index f47d459578..9bb7651edb 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,16 @@
 # RxJava Releases #
 
+### Version 1.2.8 - March 24, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.8%7C))
+
+#### API enhancements
+- [Pull 5146](https://github.com/ReactiveX/RxJava/pull/5146): Add `Single.unsubscribeOn`.
+- [Pull 5195](https://github.com/ReactiveX/RxJava/pull/5195): Enhance `UnicastSubject` with optional delay error behavior.
+
+#### Bugfixes
+
+- [Pull 5141](https://github.com/ReactiveX/RxJava/pull/5141): Fix timed `replay()` not terminating when all items timeout.
+- [Pull 5181](https://github.com/ReactiveX/RxJava/pull/5181): `replay().refCount()` avoid leaking items between connections.
+
 ### Version 1.2.7 - February 24, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.7%7C))
 
 #### Deprecation of `create(OnSubscribe)`

From 1d7edee0a60cbf185157555483db430e1afd6702 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 24 Mar 2017 10:48:10 +0100
Subject: [PATCH 230/263] Update CHANGES.md

---
 CHANGES.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGES.md b/CHANGES.md
index 9bb7651edb..c0380e97dd 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,6 @@
 # RxJava Releases #
 
-### Version 1.2.8 - March 24, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.8%7C))
+### Version 1.2.9 - March 24, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.9%7C))
 
 #### API enhancements
 - [Pull 5146](https://github.com/ReactiveX/RxJava/pull/5146): Add `Single.unsubscribeOn`.

From e37d1a75771f5abf8ffe1b1c330df34ed3bbac82 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 24 Mar 2017 20:39:31 +0100
Subject: [PATCH 231/263] 1.x: fix Completable.onErrorResumeNext unsubscribe
 not propagated (#5225)

---
 src/main/java/rx/Completable.java             |  1 +
 .../operators/CompletableOnErrorXTest.java    | 63 +++++++++++++++++++
 2 files changed, 64 insertions(+)
 create mode 100644 src/test/java/rx/internal/operators/CompletableOnErrorXTest.java

diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 536509b39a..1fb6ad1f49 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -1729,6 +1729,7 @@ public final Completable onErrorResumeNext(final Func1<? super Throwable, ? exte
             @Override
             public void call(final rx.CompletableSubscriber s) {
                 final SerialSubscription sd = new SerialSubscription();
+                s.onSubscribe(sd);
                 unsafeSubscribe(new rx.CompletableSubscriber() {
 
                     @Override
diff --git a/src/test/java/rx/internal/operators/CompletableOnErrorXTest.java b/src/test/java/rx/internal/operators/CompletableOnErrorXTest.java
new file mode 100644
index 0000000000..c462352af3
--- /dev/null
+++ b/src/test/java/rx/internal/operators/CompletableOnErrorXTest.java
@@ -0,0 +1,63 @@
+/**
+ * Copyright 2016 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+
+import rx.Completable;
+import rx.functions.Func1;
+import rx.observers.AssertableSubscriber;
+import rx.subjects.PublishSubject;
+
+public class CompletableOnErrorXTest {
+
+    @Test
+    public void nextUnsubscribe() {
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        AssertableSubscriber<Void> as = ps.toCompletable()
+        .onErrorResumeNext(new Func1<Throwable, Completable>() {
+            @Override
+            public Completable call(Throwable e) {
+                return Completable.complete();
+            }
+        })
+        .test();
+
+        assertTrue(ps.hasObservers());
+
+        as.unsubscribe();
+
+        assertFalse("Still subscribed!", ps.hasObservers());
+    }
+
+    @Test
+    public void completeUnsubscribe() {
+        PublishSubject<Integer> ps = PublishSubject.create();
+        
+        AssertableSubscriber<Void> as = ps.toCompletable()
+        .onErrorComplete()
+        .test();
+
+        assertTrue(ps.hasObservers());
+
+        as.unsubscribe();
+
+        assertFalse("Still subscribed!", ps.hasObservers());
+    }
+}

From bc40a84ffd66852ffcc320f2a2430ef52c903f61 Mon Sep 17 00:00:00 2001
From: Dan Hendry <dhendry@users.noreply.github.com>
Date: Sun, 2 Apr 2017 04:48:06 -0400
Subject: [PATCH 232/263] Defer creation of the TimeoutException when using the
 Single.timeout() operator (#5250)

* Defer creation of the TimeoutException when using the Single.timeout() operator

* Fix formatting
---
 src/main/java/rx/Single.java | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 6edb80ab15..0b39b6f24f 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -2254,7 +2254,15 @@ public final Single<T> timeout(long timeout, TimeUnit timeUnit, Single<? extends
      */
     public final Single<T> timeout(long timeout, TimeUnit timeUnit, Single<? extends T> other, Scheduler scheduler) {
         if (other == null) {
-            other = Single.<T> error(new TimeoutException());
+            // Use a defer instead of simply   other = Single.error(new TimeoutException())
+            // since instantiating an exception will cause the current stack trace to be inspected
+            // and we only want to incur that overhead when a timeout actually happens.
+            other = Single.<T>defer(new Func0<Single<T>>() {
+                @Override
+                public Single<T> call() {
+                    return Single.<T>error(new TimeoutException());
+                }
+            });
         }
         return create(new SingleTimeout<T>(onSubscribe, timeout, timeUnit, scheduler, other.onSubscribe));
     }

From 2162d6d35a8e162f408e1bfd4083924c0987751b Mon Sep 17 00:00:00 2001
From: Marko Tiidla <marko.tiidla@hotmail.com>
Date: Sun, 2 Apr 2017 12:42:10 +0200
Subject: [PATCH 233/263] 1.x Use IntelliJ IDE friendly assertion failure
 message (#5258)

* Test Intellij formatting fix

* Fix test subscriber test case
---
 src/main/java/rx/observers/TestSubscriber.java     | 4 ++--
 src/test/java/rx/observers/TestSubscriberTest.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/rx/observers/TestSubscriber.java b/src/main/java/rx/observers/TestSubscriber.java
index cfa1f74ef9..bb76878ba6 100644
--- a/src/main/java/rx/observers/TestSubscriber.java
+++ b/src/main/java/rx/observers/TestSubscriber.java
@@ -337,11 +337,11 @@ private void assertItem(T expected, int i) {
         if (expected == null) {
             // check for null equality
             if (actual != null) {
-                assertionError("Value at index: " + i + " expected to be [null] but was: [" + actual + "]\n");
+                assertionError("Value at index: " + i + " expected: [null] but was: [" + actual + "]\n");
             }
         } else if (!expected.equals(actual)) {
             assertionError("Value at index: " + i
-                    + " expected to be [" + expected + "] (" + expected.getClass().getSimpleName()
+                    + " expected: [" + expected + "] (" + expected.getClass().getSimpleName()
                     + ") but was: [" + actual + "] (" + (actual != null ? actual.getClass().getSimpleName() : "null") + ")\n");
 
         }
diff --git a/src/test/java/rx/observers/TestSubscriberTest.java b/src/test/java/rx/observers/TestSubscriberTest.java
index ee94f12297..5e2c8edc07 100644
--- a/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/src/test/java/rx/observers/TestSubscriberTest.java
@@ -72,7 +72,7 @@ public void testAssertNotMatchValue() {
         oi.subscribe(o);
 
         thrown.expect(AssertionError.class);
-        thrown.expectMessage("Value at index: 1 expected to be [3] (Integer) but was: [2] (Integer)");
+        thrown.expectMessage("Value at index: 1 expected: [3] (Integer) but was: [2] (Integer)");
 
 
         o.assertReceivedOnNext(Arrays.asList(1, 3));

From 95afbd0f1cc194a6273515f9b81f2a78b885ba32 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 26 Apr 2017 09:36:45 +0200
Subject: [PATCH 234/263] Release 1.2.10

---
 CHANGES.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index c0380e97dd..b02e08b281 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,16 @@
 # RxJava Releases #
 
+### Version 1.2.10 - April 26, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.10%7C))
+
+#### Bugfixes
+
+- [Pull 5225](https://github.com/ReactiveX/RxJava/pull/5225): Fix `Completable.onErrorResumeNext` unsubscribe not propagated.
+
+#### Other
+
+- [Pull 5250](https://github.com/ReactiveX/RxJava/pull/5250): Defer creation of the `TimeoutException` when using the `Single.timeout()` operator.
+- [Pull 5258](https://github.com/ReactiveX/RxJava/pull/5258): Use IntelliJ IDE friendly assertion failure message.
+
 ### Version 1.2.9 - March 24, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.9%7C))
 
 #### API enhancements

From 8119e786f2f61b1a762588e2edfb0d161a63ad40 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 27 Apr 2017 17:57:51 +0200
Subject: [PATCH 235/263] 1.x: apply API promotions for 1.3 (#5318)

* 1.x: apply API promotions for 1.3

* Fix typos
---
 src/main/java/rx/BackpressureOverflow.java    |   4 +-
 src/main/java/rx/Completable.java             |  13 +-
 src/main/java/rx/CompletableEmitter.java      |   4 +-
 src/main/java/rx/CompletableSubscriber.java   |   4 +-
 src/main/java/rx/Emitter.java                 |   4 +-
 src/main/java/rx/Observable.java              | 269 +++++-------------
 src/main/java/rx/Scheduler.java               |   3 +-
 src/main/java/rx/Single.java                  |  83 +++---
 src/main/java/rx/SingleEmitter.java           |   6 +-
 .../AssemblyStackTraceException.java          |   3 +-
 .../rx/exceptions/CompositeException.java     |   4 +-
 src/main/java/rx/exceptions/Exceptions.java   |  13 +-
 src/main/java/rx/functions/Cancellable.java   |   4 +-
 .../AssertableSubscriberObservable.java       |   3 +-
 .../OnSubscribeFlatMapCompletable.java        |   3 +-
 .../operators/OnSubscribeFlatMapSingle.java   |   3 +-
 .../rx/internal/schedulers/SchedulerWhen.java |   3 +-
 .../util/BackpressureDrainManager.java        |   6 +-
 .../java/rx/internal/util/BlockingUtils.java  |   4 +-
 .../java/rx/observables/AsyncOnSubscribe.java |  11 +-
 .../rx/observables/BlockingObservable.java    |  19 +-
 .../java/rx/observables/SyncOnSubscribe.java  |  13 +-
 .../rx/observers/AssertableSubscriber.java    |   5 +-
 .../observers/AsyncCompletableSubscriber.java |   4 +-
 .../observers/SafeCompletableSubscriber.java  |   4 +-
 .../java/rx/observers/TestSubscriber.java     |  10 +-
 .../RxJavaCompletableExecutionHook.java       |   4 +-
 .../java/rx/plugins/RxJavaErrorHandler.java   |   9 +-
 src/main/java/rx/plugins/RxJavaHooks.java     |   3 +-
 src/main/java/rx/plugins/RxJavaPlugins.java   |  11 +-
 .../java/rx/plugins/RxJavaSchedulersHook.java |  13 +-
 src/main/java/rx/schedulers/Schedulers.java   |   3 +-
 src/main/java/rx/singles/BlockingSingle.java  |   4 +-
 src/main/java/rx/subjects/UnicastSubject.java |   3 +-
 34 files changed, 176 insertions(+), 376 deletions(-)

diff --git a/src/main/java/rx/BackpressureOverflow.java b/src/main/java/rx/BackpressureOverflow.java
index 39948d8804..6603a6d220 100644
--- a/src/main/java/rx/BackpressureOverflow.java
+++ b/src/main/java/rx/BackpressureOverflow.java
@@ -15,15 +15,13 @@
  */
 package rx;
 
-import rx.annotations.Beta;
 import rx.exceptions.MissingBackpressureException;
 
 /**
  * Generic strategy and default implementations to deal with backpressure buffer overflows.
  * 
- * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ * @since 1.3
  */
-@Beta
 public final class BackpressureOverflow {
 
     private BackpressureOverflow() {
diff --git a/src/main/java/rx/Completable.java b/src/main/java/rx/Completable.java
index 1fb6ad1f49..1ecc1e1993 100644
--- a/src/main/java/rx/Completable.java
+++ b/src/main/java/rx/Completable.java
@@ -20,7 +20,6 @@
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import rx.annotations.*;
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.internal.observers.AssertableSubscriberObservable;
@@ -35,10 +34,9 @@
  * Represents a deferred computation without any value but only indication for completion or exception.
  *
  * The class follows a similar event pattern as Reactive-Streams: onSubscribe (onError|onComplete)?
- * 
- * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ *
+ * @since 1.3
  */
-@Beta
 public class Completable {
     /** The actual subscription action. */
     private final OnSubscribe onSubscribe;
@@ -539,9 +537,8 @@ public void call(rx.CompletableSubscriber s) {
      * Completable's protocol are held.
      * @param producer the callback invoked for each incoming CompletableSubscriber
      * @return the new Completable instance
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public static Completable fromEmitter(Action1<CompletableEmitter> producer) {
         return create(new CompletableFromEmitter(producer));
     }
@@ -2385,10 +2382,10 @@ public void call() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code test} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.3 - experimental
      * @return the new AssertableSubscriber instance
-     * @since 1.2.3
+     * @since 1.3
      */
-    @Experimental
     public final AssertableSubscriber<Void> test() {
         AssertableSubscriberObservable<Void> ts = AssertableSubscriberObservable.create(Long.MAX_VALUE);
         subscribe(ts);
diff --git a/src/main/java/rx/CompletableEmitter.java b/src/main/java/rx/CompletableEmitter.java
index 09f51e0262..dc5f83efaa 100644
--- a/src/main/java/rx/CompletableEmitter.java
+++ b/src/main/java/rx/CompletableEmitter.java
@@ -15,7 +15,6 @@
  */
 package rx;
 
-import rx.annotations.Experimental;
 import rx.functions.Cancellable;
 
 /**
@@ -24,9 +23,8 @@
  * <p>
  * All methods are thread-safe; calling onCompleted or onError twice or one after the other has
  * no effect.
- * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ * @since 1.3
  */
-@Experimental
 public interface CompletableEmitter {
 
     /**
diff --git a/src/main/java/rx/CompletableSubscriber.java b/src/main/java/rx/CompletableSubscriber.java
index 2aef783769..054a97474e 100644
--- a/src/main/java/rx/CompletableSubscriber.java
+++ b/src/main/java/rx/CompletableSubscriber.java
@@ -15,12 +15,10 @@
  */
 package rx;
 
-import rx.annotations.Experimental;
-
 /**
  * Represents the subscription API callbacks when subscribing to a Completable instance.
+ * @since 1.3
  */
-@Experimental
 public interface CompletableSubscriber {
     /**
      * Called once the deferred computation completes normally.
diff --git a/src/main/java/rx/Emitter.java b/src/main/java/rx/Emitter.java
index 5ed8697b71..3a81d7f01e 100644
--- a/src/main/java/rx/Emitter.java
+++ b/src/main/java/rx/Emitter.java
@@ -16,7 +16,6 @@
 
 package rx;
 
-import rx.annotations.Experimental;
 import rx.functions.Cancellable;
 
 /**
@@ -29,9 +28,8 @@
  * other methods are thread-safe.
  *
  * @param <T> the value type to emit
- * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ * @since 1.3
  */
-@Experimental
 public interface Emitter<T> extends Observer<T> {
 
     /**
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 6df23ff316..6c4b599bb6 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -110,7 +110,7 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
      * <p>
      * You should call the Emitter's onNext, onError and onCompleted methods in a serialized fashion. The
      * rest of its methods are thread-safe.
-     *
+     * <p>History: 1.2.7 - experimental
      * @param <T> the element type
      * @param emitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
      * @param backpressure the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
@@ -118,9 +118,8 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
      * @see Emitter
      * @see Emitter.BackpressureMode
      * @see rx.functions.Cancellable
-     * @since 1.2.7 - experimental
+     * @since 1.3
      */
-    @Experimental
     public static <T> Observable<T> create(Action1<Emitter<T>> emitter, Emitter.BackpressureMode backpressure) {
         return unsafeCreate(new OnSubscribeCreate<T>(emitter, backpressure));
     }
@@ -148,7 +147,7 @@ public static <T> Observable<T> create(Action1<Emitter<T>> emitter, Emitter.Back
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code unsafeCreate} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
-     *
+     * <p>History: 1.2.7 - experimental
      * @param <T>
      *            the type of the items that this Observable emits
      * @param f
@@ -157,9 +156,8 @@ public static <T> Observable<T> create(Action1<Emitter<T>> emitter, Emitter.Back
      * @return an Observable that, when a {@link Subscriber} subscribes to it, will execute the specified
      *         function
      * @see <a href="http://reactivex.io/documentation/operators/create.html">ReactiveX operators documentation: Create</a>
-     * @since 1.2.7 - experimental
+     * @since 1.3
      */
-    @Experimental
     public static <T> Observable<T> unsafeCreate(OnSubscribe<T> f) {
         return new Observable<T>(RxJavaHooks.onCreate(f));
     }
@@ -243,9 +241,9 @@ public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe)
      * @see AsyncOnSubscribe#createStateless(Action2)
      * @see AsyncOnSubscribe#createStateless(Action2, Action0)
      * @see <a href="http://reactivex.io/documentation/operators/create.html">ReactiveX operators documentation: Create</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3 - beta
      */
-    @Experimental
+    @Beta
     public static <S, T> Observable<T> create(AsyncOnSubscribe<S, T> asyncOnSubscribe) {
         return unsafeCreate(asyncOnSubscribe);
     }
@@ -350,8 +348,8 @@ public interface Transformer<T, R> extends Func1<Observable<T>, Observable<R>> {
      * @param <R> the resulting object type
      * @param converter the function that receives the current Observable instance and returns a value
      * @return the value returned by the function
+     * @since 1.3
      */
-    @Experimental
     public final <R> R to(Func1<? super Observable<T>, R> converter) {
         return converter.call(this);
     }
@@ -402,10 +400,8 @@ public Single<T> toSingle() {
      *         calls onCompleted
      * @see <a href="http://reactivex.io/documentation/completable.html">ReactiveX documentation:
      *      Completable</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical
-     *        with the release number)
+     * @since 1.3
      */
-    @Beta
     public Completable toCompletable() {
         return Completable.fromObservable(this);
     }
@@ -1494,10 +1490,9 @@ public static <T> Observable<T> concat(Observable<? extends T> t1, Observable<?
      * @param <T> the common element base type
      * @param sources the Observable sequence of Observables
      * @return the new Observable with the concatenating behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
-    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends Observable<? extends T>> sources) {
         return sources.concatMapDelayError((Func1)UtilityFunctions.identity());
     }
@@ -1519,9 +1514,8 @@ public static <T> Observable<T> concatDelayError(Observable<? extends Observable
      * @param <T> the common element base type
      * @param sources the Iterable sequence of Observables
      * @return the new Observable with the concatenating behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Observable<T> concatDelayError(Iterable<? extends Observable<? extends T>> sources) {
         return concatDelayError(from(sources));
     }
@@ -1546,9 +1540,8 @@ public static <T> Observable<T> concatDelayError(Iterable<? extends Observable<?
      * @param t2
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2) {
         return concatDelayError(just(t1, t2));
     }
@@ -1575,9 +1568,8 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t3
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2,Observable<? extends T> t3 ) {
         return concatDelayError(just(t1, t2, t3));
     }
@@ -1606,9 +1598,8 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t4
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
         return concatDelayError(just(t1, t2, t3, t4));
     }
@@ -1639,9 +1630,8 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t5
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
         return concatDelayError(just(t1, t2, t3, t4, t5));
     }
@@ -1674,9 +1664,8 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t6
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
         return concatDelayError(just(t1, t2, t3, t4, t5, t6));
     }
@@ -1711,9 +1700,8 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t7
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
         return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7));
     }
@@ -1750,9 +1738,8 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t8
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
         return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7, t8));
     }
@@ -1791,9 +1778,8 @@ public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Obs
      * @param t9
      *            an Observable to be concatenated
      * @return an Observable with the concatenating behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Observable<T> concatDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
         return concatDelayError(just(t1, t2, t3, t4, t5, t6, t7, t8, t9));
     }
@@ -2026,54 +2012,6 @@ public static <T> Observable<T> from(T[] array) {
         return unsafeCreate(new OnSubscribeFromArray<T>(array));
     }
 
-    /**
-     * Provides an API (via a cold Observable) that bridges the reactive world with the callback-style,
-     * generally non-backpressured world.
-     * <p>
-     * Example:
-     * <pre><code>
-     * Observable.&lt;Event&gt;fromEmitter(emitter -&gt; {
-     *     Callback listener = new Callback() {
-     *         &#64;Override
-     *         public void onEvent(Event e) {
-     *             emitter.onNext(e);
-     *             if (e.isLast()) {
-     *                 emitter.onCompleted();
-     *             }
-     *         }
-     *
-     *         &#64;Override
-     *         public void onFailure(Exception e) {
-     *             emitter.onError(e);
-     *         }
-     *     };
-     *
-     *     AutoCloseable c = api.someMethod(listener);
-     *
-     *     emitter.setCancellation(c::close);
-     *
-     * }, BackpressureMode.BUFFER);
-     * </code></pre>
-     * <p>
-     * You should call the Emitter's onNext, onError and onCompleted methods in a serialized fashion. The
-     * rest of its methods are thread-safe.
-     *
-     * @param <T> the element type
-     * @param emitter the emitter that is called when a Subscriber subscribes to the returned {@code Observable}
-     * @param backpressure the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
-     * @return the new Observable instance
-     * @see Emitter
-     * @see Emitter.BackpressureMode
-     * @see rx.functions.Cancellable
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
-     * @deprecated 1.2.7 - aliased to {@link #create(Action1, rx.Emitter.BackpressureMode)}, will be removed in 1.3.0
-     */
-    @Experimental
-    @Deprecated
-    public static <T> Observable<T> fromEmitter(Action1<Emitter<T>> emitter, Emitter.BackpressureMode backpressure) {
-        return unsafeCreate(new OnSubscribeCreate<T>(emitter, backpressure));
-    }
-
     /**
      * Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then
      * emits the value returned from that function.
@@ -3068,9 +3006,8 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends Observable<
      * @return an Observable that emits all of the items emitted by the Observables emitted by the
      *         {@code source} Observable
      * @see <a href="http://reactivex.io/documentation/operators/merge.html">ReactiveX operators documentation: Merge</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Observable<T> mergeDelayError(Observable<? extends Observable<? extends T>> source, int maxConcurrent) {
         return source.lift(OperatorMerge.<T>instance(true, maxConcurrent));
     }
@@ -3684,10 +3621,8 @@ public static <T> Observable<T> switchOnNext(Observable<? extends Observable<? e
      * @return an Observable that emits the items emitted by the Observable most recently emitted by the source
      *         Observable
      * @see <a href="http://reactivex.io/documentation/operators/switch.html">ReactiveX operators documentation: Switch</a>
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Observable<T> switchOnNextDelayError(Observable<? extends Observable<? extends T>> sequenceOfSequences) {
         return sequenceOfSequences.lift(OperatorSwitch.<T>instance(true));
     }
@@ -3861,10 +3796,8 @@ public static <T, Resource> Observable<T> using(
      *            a terminal event ({@code onComplete} or {@code onError}).
      * @return the Observable whose lifetime controls the lifetime of the dependent resource object
      * @see <a href="http://reactivex.io/documentation/operators/using.html">ReactiveX operators documentation: Using</a>
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T, Resource> Observable<T> using(
             final Func0<Resource> resourceFactory,
             final Func1<? super Resource, ? extends Observable<? extends T>> observableFactory,
@@ -3966,8 +3899,8 @@ public static <R> Observable<R> zip(Iterable<? extends Observable<?>> ws, FuncN<
      *            an item that will be emitted by the resulting Observable
      * @return an Observable that emits the zipped results
      * @see <a href="http://reactivex.io/documentation/operators/zip.html">ReactiveX operators documentation: Zip</a>
+     * @since 1.3
      */
-    @Experimental
     public static <R> Observable<R> zip(Observable<?>[] ws, FuncN<? extends R> zipFunction) {
         return Observable.just(ws).lift(new OperatorZip<R>(zipFunction));
     }
@@ -5192,9 +5125,8 @@ public final <R> Observable<R> concatMap(Func1<? super T, ? extends Observable<?
      * @param <R> the result value type
      * @param func the function that maps the items of this Observable into the inner Observables.
      * @return the new Observable instance with the concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final <R> Observable<R> concatMapDelayError(Func1<? super T, ? extends Observable<?extends R>> func) {
         if (this instanceof ScalarSynchronousObservable) {
             ScalarSynchronousObservable<T> scalar = (ScalarSynchronousObservable<T>) this;
@@ -5692,9 +5624,8 @@ public final <U> Observable<T> delaySubscription(Func0<? extends Observable<U>>
      *        to this Observable.
      * @return an Observable that delays the subscription to this Observable
      *         until the other Observable emits an element or completes normally.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final <U> Observable<T> delaySubscription(Observable<U> other) {
         if (other == null) {
             throw new NullPointerException();
@@ -5836,10 +5767,8 @@ public final <U> Observable<T> distinctUntilChanged(Func1<? super T, ? extends U
      * @return an Observable that emits those items from the source Observable that are distinct from their
      *         immediate predecessors
      * @see <a href="http://reactivex.io/documentation/operators/distinct.html">ReactiveX operators documentation: Distinct</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical
-     *        with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Observable<T> distinctUntilChanged(Func2<? super T, ? super T, Boolean> comparator) {
         return lift(new OperatorDistinctUntilChanged<T, T>(comparator));
     }
@@ -6098,9 +6027,8 @@ public final Observable<T> doOnUnsubscribe(final Action0 unsubscribe) {
      * @param o1 the first source
      * @param o2 the second source
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(Observable<? extends T> o1, Observable<? extends T> o2) {
         return concatEager(Arrays.asList(o1, o2));
@@ -6124,9 +6052,8 @@ public static <T> Observable<T> concatEager(Observable<? extends T> o1, Observab
      * @param o2 the second source
      * @param o3 the third source
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6154,9 +6081,8 @@ public static <T> Observable<T> concatEager(
      * @param o3 the third source
      * @param o4 the fourth source
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6185,9 +6111,8 @@ public static <T> Observable<T> concatEager(
      * @param o4 the fourth source
      * @param o5 the fifth source
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6218,9 +6143,8 @@ public static <T> Observable<T> concatEager(
      * @param o5 the fifth source
      * @param o6 the sixth source
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6252,9 +6176,8 @@ public static <T> Observable<T> concatEager(
      * @param o6 the sixth source
      * @param o7 the seventh source
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6288,9 +6211,8 @@ public static <T> Observable<T> concatEager(
      * @param o7 the seventh source
      * @param o8 the eighth source
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6325,9 +6247,8 @@ public static <T> Observable<T> concatEager(
      * @param o8 the eighth source
      * @param o9 the ninth source
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings("unchecked")
     public static <T> Observable<T> concatEager(
             Observable<? extends T> o1, Observable<? extends T> o2,
@@ -6355,9 +6276,8 @@ public static <T> Observable<T> concatEager(
      * @param <T> the value type
      * @param sources a sequence of Observables that need to be eagerly concatenated
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public static <T> Observable<T> concatEager(Iterable<? extends Observable<? extends T>> sources) {
         return Observable.from(sources).concatMapEager((Func1)UtilityFunctions.identity());
@@ -6380,9 +6300,8 @@ public static <T> Observable<T> concatEager(Iterable<? extends Observable<? exte
      * @param sources a sequence of Observables that need to be eagerly concatenated
      * @param capacityHint hints about the number of expected source sequence values
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public static <T> Observable<T> concatEager(Iterable<? extends Observable<? extends T>> sources, int capacityHint) {
         return Observable.from(sources).concatMapEager((Func1)UtilityFunctions.identity(), capacityHint);
@@ -6404,9 +6323,8 @@ public static <T> Observable<T> concatEager(Iterable<? extends Observable<? exte
      * @param <T> the value type
      * @param sources a sequence of Observables that need to be eagerly concatenated
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public static <T> Observable<T> concatEager(Observable<? extends Observable<? extends T>> sources) {
         return sources.concatMapEager((Func1)UtilityFunctions.identity());
@@ -6429,9 +6347,8 @@ public static <T> Observable<T> concatEager(Observable<? extends Observable<? ex
      * @param sources a sequence of Observables that need to be eagerly concatenated
      * @param capacityHint hints about the number of expected source sequence values
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public static <T> Observable<T> concatEager(Observable<? extends Observable<? extends T>> sources, int capacityHint) {
         return sources.concatMapEager((Func1)UtilityFunctions.identity(), capacityHint);
@@ -6455,9 +6372,8 @@ public static <T> Observable<T> concatEager(Observable<? extends Observable<? ex
      * @param mapper the function that maps a sequence of values into a sequence of Observables that will be
      *               eagerly concatenated
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observable<? extends R>> mapper) {
         return concatMapEager(mapper, RxRingBuffer.SIZE);
     }
@@ -6481,9 +6397,8 @@ public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observa
      *               eagerly concatenated
      * @param capacityHint hints about the number of expected source sequence values
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observable<? extends R>> mapper, int capacityHint) {
         if (capacityHint < 1) {
             throw new IllegalArgumentException("capacityHint > 0 required but it was " + capacityHint);
@@ -6511,9 +6426,8 @@ public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observa
      * @param capacityHint hints about the number of expected source sequence values
      * @param maxConcurrent the maximum number of concurrent subscribed observables
      * @return the new Observable instance with the specified concatenation behavior
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observable<? extends R>> mapper, int capacityHint, int maxConcurrent) {
         if (capacityHint < 1) {
             throw new IllegalArgumentException("capacityHint > 0 required but it was " + capacityHint);
@@ -6983,13 +6897,13 @@ public final <U, R> Observable<R> flatMap(final Func1<? super T, ? extends Obser
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapCompletable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.7 - experimental
      * @param mapper the function that receives an upstream value and turns it into a Completable
      *               to be merged.
      * @return the new Observable instance
      * @see #flatMapCompletable(Func1, boolean, int)
-     * @since 1.2.7 - experimental
+     * @since 1.3
      */
-    @Experimental
     public final Observable<T> flatMapCompletable(Func1<? super T, ? extends Completable> mapper) {
         return flatMapCompletable(mapper, false, Integer.MAX_VALUE);
     }
@@ -7004,15 +6918,15 @@ public final Observable<T> flatMapCompletable(Func1<? super T, ? extends Complet
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapCompletable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.7 - experimental
      * @param mapper the function that receives an upstream value and turns it into a Completable
      *               to be merged.
      * @param delayErrors if true, errors from the upstream and from the inner Completables get delayed till
      *                    the all of them terminate.
      * @return the new Observable instance
-     * @since 1.2.7 - experimental
+     * @since 1.3
      * @see #flatMapCompletable(Func1, boolean, int)
      */
-    @Experimental
     public final Observable<T> flatMapCompletable(Func1<? super T, ? extends Completable> mapper, boolean delayErrors) {
         return flatMapCompletable(mapper, delayErrors, Integer.MAX_VALUE);
     }
@@ -7028,15 +6942,15 @@ public final Observable<T> flatMapCompletable(Func1<? super T, ? extends Complet
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapCompletable} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.7 - experimental
      * @param mapper the function that receives an upstream value and turns it into a Completable
      *               to be merged.
      * @param delayErrors if true, errors from the upstream and from the inner Completables get delayed till
      *                    the all of them terminate.
      * @param maxConcurrency the maximum number of inner Completables to run at a time
      * @return the new Observable instance
-     * @since 1.2.7 - experimental
+     * @since 1.3
      */
-    @Experimental
     public final Observable<T> flatMapCompletable(Func1<? super T, ? extends Completable> mapper, boolean delayErrors, int maxConcurrency) {
         return unsafeCreate(new OnSubscribeFlatMapCompletable<T>(this, mapper, delayErrors, maxConcurrency));
     }
@@ -7183,14 +7097,14 @@ public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Ite
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.7 - experimental
      * @param <R> the value type of the inner Singles and the resulting Observable
      * @param mapper the function that receives an upstream value and turns it into a Single
      *               to be merged.
      * @return the new Observable instance
      * @see #flatMapSingle(Func1, boolean, int)
-     * @since 1.2.7 - experimental
+     * @since 1.3
      */
-    @Experimental
     public final <R> Observable<R> flatMapSingle(Func1<? super T, ? extends Single<? extends R>> mapper) {
         return flatMapSingle(mapper, false, Integer.MAX_VALUE);
     }
@@ -7204,16 +7118,16 @@ public final <R> Observable<R> flatMapSingle(Func1<? super T, ? extends Single<?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.7 - experimental
      * @param <R> the value type of the inner Singles and the resulting Observable
      * @param mapper the function that receives an upstream value and turns it into a Single
      *               to be merged.
      * @param delayErrors if true, errors from the upstream and from the inner Singles get delayed till
      *                    the all of them terminate.
      * @return the new Observable instance
-     * @since 1.2.7 - experimental
+     * @since 1.3
      * @see #flatMapSingle(Func1, boolean, int)
      */
-    @Experimental
     public final <R> Observable<R> flatMapSingle(Func1<? super T, ? extends Single<? extends R>> mapper, boolean delayErrors) {
         return flatMapSingle(mapper, delayErrors, Integer.MAX_VALUE);
     }
@@ -7228,6 +7142,7 @@ public final <R> Observable<R> flatMapSingle(Func1<? super T, ? extends Single<?
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.7 - experimental
      * @param <R> the value type of the inner Singles and the resulting Observable
      * @param mapper the function that receives an upstream value and turns it into a Single
      *               to be merged.
@@ -7235,9 +7150,8 @@ public final <R> Observable<R> flatMapSingle(Func1<? super T, ? extends Single<?
      *                    the all of them terminate.
      * @param maxConcurrency the maximum number of inner Singles to run at a time
      * @return the new Observable instance
-     * @since 1.2.7 - experimental
+     * @since 1.3
      */
-    @Experimental
     public final <R> Observable<R> flatMapSingle(Func1<? super T, ? extends Single<? extends R>> mapper, boolean delayErrors, int maxConcurrency) {
         return unsafeCreate(new OnSubscribeFlatMapSingle<T, R>(this, mapper, delayErrors, maxConcurrency));
     }
@@ -7419,8 +7333,8 @@ public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? su
      * @throws NullPointerException
      *             if {@code evictingMapFactory} is null
      * @see <a href="http://reactivex.io/documentation/operators/groupby.html">ReactiveX operators documentation: GroupBy</a>
+     * @since 1.3
      */
-    @Experimental
     public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? super T, ? extends K> keySelector,
             final Func1<? super T, ? extends R> elementSelector, final Func1<Action1<K>, Map<K, Object>> evictingMapFactory) {
         if (evictingMapFactory == null) {
@@ -8049,9 +7963,8 @@ public final Observable<T> onBackpressureBuffer(long capacity, Action0 onOverflo
      * @param overflowStrategy how should the {@code Observable} react to buffer overflows.  Null is not allowed.
      * @return the source {@code Observable} modified to buffer items up to the given capacity
      * @see <a href="http://reactivex.io/documentation/operators/backpressure.html">ReactiveX operators documentation: backpressure operators</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Observable<T> onBackpressureBuffer(long capacity, Action0 onOverflow, BackpressureOverflow.Strategy overflowStrategy) {
         return lift(new OperatorOnBackpressureBuffer<T>(capacity, onOverflow, overflowStrategy));
     }
@@ -8075,7 +7988,6 @@ public final Observable<T> onBackpressureBuffer(long capacity, Action0 onOverflo
      * @param onDrop the action to invoke for each item dropped. onDrop action should be fast and should never block.
      * @return the source Observable modified to drop {@code onNext} notifications on overflow
      * @see <a href="http://reactivex.io/documentation/operators/backpressure.html">ReactiveX operators documentation: backpressure operators</a>
-     * @Experimental The behavior of this can change at any time.
      * @since 1.1.0
      */
     public final Observable<T> onBackpressureDrop(Action1<? super T> onDrop) {
@@ -8306,9 +8218,8 @@ public final Observable<T> onExceptionResumeNext(final Observable<? extends T> r
      * </dl>
      * @return an Observable which out references to the upstream producer and downstream Subscriber if
      * the sequence is terminated or downstream unsubscribes
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final Observable<T> onTerminateDetach() {
         return unsafeCreate(new OnSubscribeDetach<T>(this));
     }
@@ -8381,9 +8292,8 @@ public final <R> Observable<R> publish(Func1<? super Observable<T>, ? extends Ob
      *
      * @param n the initial request amount, further request will happen after 75% of this value
      * @return the Observable that rebatches request amounts from downstream
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final Observable<T> rebatchRequests(int n) {
         if (n <= 0) {
             throw new IllegalArgumentException("n > 0 required but it was " + n);
@@ -10511,7 +10421,7 @@ public final Observable<T> subscribeOn(Scheduler scheduler) {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>you specify which {@link Scheduler} this operator will use</dd>
      * </dl>
-     *
+     * <p>History: 1.2.7 - experimental
      * @param scheduler
      *            the {@link Scheduler} to perform subscription actions on
      * @param requestOn if true, requests are rerouted to the given Scheduler as well (strong pipelining)
@@ -10523,9 +10433,8 @@ public final Observable<T> subscribeOn(Scheduler scheduler) {
      * @see <a href="http://www.grahamlea.com/2014/07/rxjava-threading-examples/">RxJava Threading Examples</a>
      * @see #observeOn
      * @see #subscribeOn(Scheduler)
-     * @since 1.2.7 - experimental
+     * @since 1.3
      */
-    @Experimental
     public final Observable<T> subscribeOn(Scheduler scheduler, boolean requestOn) {
         if (this instanceof ScalarSynchronousObservable) {
             return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
@@ -10589,10 +10498,8 @@ public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<?
      *            Observable
      * @return an Observable that emits the items emitted by the Observable returned from applying {@code func} to the most recently emitted item emitted by the source Observable
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final <R> Observable<R> switchMapDelayError(Func1<? super T, ? extends Observable<? extends R>> func) {
         return switchOnNextDelayError(map(func));
     }
@@ -11929,9 +11836,8 @@ public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Intege
      *             if any item emitted by the Observable does not implement {@link Comparable} with respect to
      *             all other items emitted by the Observable
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Observable<List<T>> toSortedList(int initialCapacity) {
         return lift(new OperatorToObservableSortedList<T>(initialCapacity));
     }
@@ -11957,9 +11863,8 @@ public final Observable<List<T>> toSortedList(int initialCapacity) {
      * @return an Observable that emits a list that contains the items emitted by the source Observable in
      *         sorted order
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Integer> sortFunction, int initialCapacity) {
         return lift(new OperatorToObservableSortedList<T>(sortFunction, initialCapacity));
     }
@@ -11984,8 +11889,8 @@ public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Intege
      *             if any item emitted by the Observable does not implement {@link Comparable} with respect to
      *             all other items emitted by the Observable
      * @return an Observable that emits the items emitted by the source Observable in sorted order
+     * @since 1.3
      */
-    @Experimental
     public final Observable<T> sorted() {
         return toSortedList().flatMapIterable(UtilityFunctions.<List<T>>identity());
     }
@@ -12009,8 +11914,8 @@ public final Observable<T> sorted() {
      *            a function that compares two items emitted by the source Observable and returns an Integer
      *            that indicates their sort order
      * @return an Observable that emits the items emitted by the source Observable in sorted order
+     * @since 1.3
      */
-    @Experimental
     public final Observable<T> sorted(Func2<? super T, ? super T, Integer> sortFunction) {
         return toSortedList(sortFunction).flatMapIterable(UtilityFunctions.<List<T>>identity());
     }
@@ -12061,11 +11966,9 @@ public final Observable<T> unsubscribeOn(Scheduler scheduler) {
      * @return an Observable that merges the specified Observable into this Observable by using the
      *         {@code resultSelector} function only when the source Observable sequence (this instance) emits an
      *         item
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      * @see <a href="http://reactivex.io/documentation/operators/combinelatest.html">ReactiveX operators documentation: CombineLatest</a>
      */
-    @Experimental
     public final <U, R> Observable<R> withLatestFrom(Observable<? extends U> other, Func2<? super T, ? super U, ? extends R> resultSelector) {
         return lift(new OperatorWithLatestFrom<T, U, R>(other, resultSelector));
     }
@@ -12094,10 +11997,8 @@ public final <U, R> Observable<R> withLatestFrom(Observable<? extends U> other,
      * @param o2 the second other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final <T1, T2, R> Observable<R> withLatestFrom(Observable<T1> o1, Observable<T2> o2, Func3<? super T, ? super T1, ? super T2, R> combiner) {
         return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this, new Observable<?>[] { o1, o2 }, null, Functions.fromFunc(combiner)));
     }
@@ -12128,10 +12029,8 @@ public final <T1, T2, R> Observable<R> withLatestFrom(Observable<T1> o1, Observa
      * @param o3 the third other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final <T1, T2, T3, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3,
@@ -12168,10 +12067,8 @@ public final <T1, T2, T3, R> Observable<R> withLatestFrom(
      * @param o4 the fourth other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final <T1, T2, T3, T4, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3, Observable<T4> o4,
@@ -12209,10 +12106,8 @@ public final <T1, T2, T3, T4, R> Observable<R> withLatestFrom(
      * @param o5 the fifth other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final <T1, T2, T3, T4, T5, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3, Observable<T4> o4,
@@ -12254,10 +12149,8 @@ public final <T1, T2, T3, T4, T5, R> Observable<R> withLatestFrom(
      * @param o6 the sixth other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final <T1, T2, T3, T4, T5, T6, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3, Observable<T4> o4,
@@ -12301,10 +12194,8 @@ public final <T1, T2, T3, T4, T5, T6, R> Observable<R> withLatestFrom(
      * @param o7 the seventh other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3, Observable<T4> o4,
@@ -12351,10 +12242,8 @@ public final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> withLatestFrom(
      * @param o8 the eighth other Observable
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> withLatestFrom(
             Observable<T1> o1, Observable<T2> o2,
             Observable<T3> o3, Observable<T4> o4,
@@ -12386,10 +12275,8 @@ public final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> withLatestFrom(
      * @param others the array of other sources
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final <R> Observable<R> withLatestFrom(Observable<?>[] others, FuncN<R> combiner) {
         return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this, others, null, combiner));
     }
@@ -12415,10 +12302,8 @@ public final <R> Observable<R> withLatestFrom(Observable<?>[] others, FuncN<R> c
      * @param others the iterable of other sources
      * @param combiner the function called with an array of values from each participating observable
      * @return the new Observable instance
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final <R> Observable<R> withLatestFrom(Iterable<Observable<?>> others, FuncN<R> combiner) {
         return unsafeCreate(new OperatorWithLatestFromMany<T, R>(this, null, others, combiner));
     }
@@ -12899,10 +12784,10 @@ public final <T2, R> Observable<R> zipWith(Observable<? extends T2> other, Func2
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code test} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.3 - experimental
      * @return the new AssertableSubscriber instance
-     * @since 1.2.3
+     * @since 1.3
      */
-    @Experimental
     public final AssertableSubscriber<T> test() {
         AssertableSubscriber<T> ts = AssertableSubscriberObservable.create(Long.MAX_VALUE);
         subscribe(ts);
@@ -12918,11 +12803,11 @@ public final AssertableSubscriber<T> test() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code test} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.3 - experimental
      * @return the new AssertableSubscriber instance
      * @param initialRequestAmount the amount to request from upstream upfront, non-negative (not verified)
-     * @since 1.2.3
+     * @since 1.3
      */
-    @Experimental
     public final AssertableSubscriber<T> test(long initialRequestAmount) {
         AssertableSubscriber<T> ts = AssertableSubscriberObservable.create(initialRequestAmount);
         subscribe(ts);
diff --git a/src/main/java/rx/Scheduler.java b/src/main/java/rx/Scheduler.java
index b98615ff47..89259b178b 100644
--- a/src/main/java/rx/Scheduler.java
+++ b/src/main/java/rx/Scheduler.java
@@ -17,7 +17,6 @@
 
 import java.util.concurrent.TimeUnit;
 
-import rx.annotations.Experimental;
 import rx.functions.*;
 import rx.internal.schedulers.*;
 import rx.schedulers.Schedulers;
@@ -203,9 +202,9 @@ public long now() {
      * @param combine the function that takes a two-level nested Observable sequence of a Completable and returns
      * the Completable that will be subscribed to and should trigger the execution of the scheduled Actions.
      * @return the Scheduler with the customized execution behavior
+     * @since 1.3
      */
     @SuppressWarnings("unchecked")
-    @Experimental
     public <S extends Scheduler & Subscription> S when(Func1<Observable<Observable<Completable>>, Completable> combine) {
         return (S) new SchedulerWhen(combine, this);
     }
diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index 0b39b6f24f..a9bff5e388 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -145,8 +145,8 @@ public interface OnSubscribe<T> extends Action1<SingleSubscriber<? super T>> {
      *            the Operator that implements the Single-operating function to be applied to the source Single
      * @return a Single that is the result of applying the lifted Operator to the source Single
      * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Implementing-Your-Own-Operators">RxJava wiki: Implementing Your Own Operators</a>
+     * @since 1.3
      */
-    @Beta
     public final <R> Single<R> lift(final Operator<? extends R, ? super T> lift) {
         return create(new SingleLiftObservableOperator<T, R>(this.onSubscribe, lift));
     }
@@ -602,12 +602,12 @@ public static <T> Single<T> fromCallable(final Callable<? extends T> func) {
      * </code></pre>
      * <p>All of the SingleEmitter's methods are thread-safe and ensure the
      * Single's protocol are held.
+     * <p>History: 1.2.3 - experimental
      * @param <T> the success value type
      * @param producer the callback invoked for each incoming SingleSubscriber
      * @return the new Single instance
-     * @since 1.2.3 - experimental (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public static <T> Single<T> fromEmitter(Action1<SingleEmitter<T>> producer) {
         if (producer == null) { throw new NullPointerException("producer is null"); }
         return create(new SingleFromEmitter<T>(producer));
@@ -939,15 +939,15 @@ public static <T> Observable<T> merge(Single<? extends T> t1, Single<? extends T
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.7 - experimental
      * @param <T> the value type of the inner Singles and the resulting Observable
      * @param sources the Observable that emits Singles to be merged
      * @return the new Observable instance
      * @see #merge(Observable, int)
      * @see #mergeDelayError(Observable)
      * @see #mergeDelayError(Observable, int)
-     * @since 1.2.7 - experimental
+     * @since 1.3
      */
-    @Experimental
     public static <T> Observable<T> merge(Observable<? extends Single<? extends T>> sources) {
         return merge(sources, Integer.MAX_VALUE);
     }
@@ -963,14 +963,14 @@ public static <T> Observable<T> merge(Observable<? extends Single<? extends T>>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.7 - experimental
      * @param <T> the value type of the inner Singles and the resulting Observable
      * @param sources the Observable that emits Singles to be merged
      * @param maxConcurrency the maximum number of inner Singles to run at a time
      * @return the new Observable instance
-     * @since 1.2.7 - experimental
+     * @since 1.3
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
-    @Experimental
     public static <T> Observable<T> merge(Observable<? extends Single<? extends T>> sources, int maxConcurrency) {
         return sources.flatMapSingle((Func1)UtilityFunctions.identity(), false, maxConcurrency);
     }
@@ -985,15 +985,15 @@ public static <T> Observable<T> merge(Observable<? extends Single<? extends T>>
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code merge} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.7 - experimental
      * @param <T> the value type of the inner Singles and the resulting Observable
      * @param sources the Observable that emits Singles to be merged
      * @return the new Observable instance
      * @see #mergeDelayError(Observable, int)
      * @see #merge(Observable)
      * @see #merge(Observable, int)
-     * @since 1.2.7 - experimental
+     * @since 1.3
      */
-    @Experimental
     public static <T> Observable<T> mergeDelayError(Observable<? extends Single<? extends T>> sources) {
         return merge(sources, Integer.MAX_VALUE);
     }
@@ -1009,14 +1009,14 @@ public static <T> Observable<T> mergeDelayError(Observable<? extends Single<? ex
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code flatMapSingle} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.7 - experimental
      * @param <T> the value type of the inner Singles and the resulting Observable
      * @param sources the Observable that emits Singles to be merged
      * @param maxConcurrency the maximum number of inner Singles to run at a time
      * @return the new Observable instance
-     * @since 1.2.7 - experimental
+     * @since 1.3
      */
     @SuppressWarnings({ "unchecked", "rawtypes" })
-    @Experimental
     public static <T> Observable<T> mergeDelayError(Observable<? extends Single<? extends T>> sources, int maxConcurrency) {
         return sources.flatMapSingle((Func1)UtilityFunctions.identity(), true, maxConcurrency);
     }
@@ -1452,8 +1452,8 @@ public static <R> Single<R> zip(Iterable<? extends Single<?>> singles, FuncN<? e
      * @return a Single that, when first subscribed to, caches its response for the
      *         benefit of subsequent subscribers
      * @see <a href="http://reactivex.io/documentation/operators/replay.html">ReactiveX operators documentation: Replay</a>
+     * @since 1.3
      */
-    @Experimental
     public final Single<T> cache() {
         return toObservable().cacheWithInitialCapacity(1).toSingle();
     }
@@ -1537,9 +1537,8 @@ public final <R> Observable<R> flatMapObservable(Func1<? super T, ? extends Obse
      *            Completable
      * @return the Completable returned from {@code func} when applied to the item emitted by the source Single
      * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Completable flatMapCompletable(final Func1<? super T, ? extends Completable> func) {
         return Completable.create(new CompletableFlatMapSingleToCompletable<T>(this, func));
     }
@@ -1669,10 +1668,8 @@ public final Single<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunctio
      * @param resumeSingleInCaseOfError a Single that will take control if source Single encounters an error.
      * @return the original Single, with appropriately modified behavior.
      * @see <a href="http://reactivex.io/documentation/operators/catch.html">ReactiveX operators documentation: Catch</a>
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Single<T> onErrorResumeNext(Single<? extends T> resumeSingleInCaseOfError) {
         return new Single<T>(SingleOperatorOnErrorResumeNext.withOther(this, resumeSingleInCaseOfError));
     }
@@ -1703,10 +1700,8 @@ public final Single<T> onErrorResumeNext(Single<? extends T> resumeSingleInCaseO
      * @param resumeFunctionInCaseOfError a function that returns a Single that will take control if source Single encounters an error.
      * @return the original Single, with appropriately modified behavior.
      * @see <a href="http://reactivex.io/documentation/operators/catch.html">ReactiveX operators documentation: Catch</a>
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Single<T> onErrorResumeNext(final Func1<Throwable, ? extends Single<? extends T>> resumeFunctionInCaseOfError) {
         return new Single<T>(SingleOperatorOnErrorResumeNext.withFunction(this, resumeFunctionInCaseOfError));
     }
@@ -2117,8 +2112,8 @@ public final <E> Single<T> takeUntil(final Single<? extends E> other) {
      * @param <R> the resulting object type
      * @param converter the function that receives the current Single instance and returns a value
      * @return the value returned by the function
+     * @since 1.3
      */
-    @Experimental
     public final <R> R to(Func1<? super Single<T>, R> converter) {
         return converter.call(this);
     }
@@ -2150,10 +2145,8 @@ public final Observable<T> toObservable() {
      * @return a {@link Completable} that calls {@code onCompleted} on it's subscriber when the source {@link Single}
      *         calls {@code onSuccess}.
      * @see <a href="http://reactivex.io/documentation/completable.html">ReactiveX documentation: Completable</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical
-     *        with the release number).
+     * @since 1.3
      */
-    @Beta
     public final Completable toCompletable() {
         return Completable.fromSingle(this);
     }
@@ -2276,8 +2269,8 @@ public Single<T> call() {
      *
      * @return a {@code BlockingSingle} version of this Single.
      * @see <a href="http://reactivex.io/documentation/operators/to.html">ReactiveX operators documentation: To</a>
+     * @since 1.3
      */
-    @Beta
     public final BlockingSingle<T> toBlocking() {
         return BlockingSingle.from(this);
     }
@@ -2326,9 +2319,8 @@ public final <T2, R> Single<R> zipWith(Single<? extends T2> other, Func2<? super
      *            the action to invoke if the source {@link Single} calls {@code onError}
      * @return the source {@link Single} with the side-effecting behavior applied
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Single<T> doOnError(final Action1<Throwable> onError) {
         if (onError == null) {
             throw new IllegalArgumentException("onError is null");
@@ -2355,9 +2347,8 @@ public void call(final Throwable throwable) {
      *            the action to invoke when the source {@link Single} calls {@code onSuccess} or {@code onError}.
      * @return the source {@link Single} with the side-effecting behavior applied
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final Single<T> doOnEach(final Action1<Notification<? extends T>> onNotification) {
         if (onNotification == null) {
             throw new IllegalArgumentException("onNotification is null");
@@ -2389,9 +2380,8 @@ public void call(final Throwable throwable) {
      *            the action to invoke when the source {@link Single} calls {@code onSuccess}
      * @return the source {@link Single} with the side-effecting behavior applied
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final Single<T> doOnSuccess(final Action1<? super T> onSuccess) {
         if (onSuccess == null) {
             throw new IllegalArgumentException("onSuccess is null");
@@ -2417,9 +2407,8 @@ public final Single<T> doOnSuccess(final Action1<? super T> onSuccess) {
      *            the action that gets called when an observer subscribes to this {@code Single}
      * @return the source {@code Single} modified so as to call this Action when appropriate
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Single<T> doOnSubscribe(final Action0 subscribe) {
         return create(new SingleDoOnSubscribe<T>(onSubscribe, subscribe));
     }
@@ -2442,9 +2431,8 @@ public final Single<T> doOnSubscribe(final Action0 subscribe) {
      *            the {@link Scheduler} to use for delaying
      * @return the source Single shifted in time by the specified delay
      * @see <a href="http://reactivex.io/documentation/operators/delay.html">ReactiveX operators documentation: Delay</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Single<T> delay(long delay, TimeUnit unit, Scheduler scheduler) {
         return create(new SingleDelay<T>(onSubscribe, delay, unit, scheduler));
     }
@@ -2465,9 +2453,8 @@ public final Single<T> delay(long delay, TimeUnit unit, Scheduler scheduler) {
      *            the {@link TimeUnit} in which {@code period} is defined
      * @return the source Single shifted in time by the specified delay
      * @see <a href="http://reactivex.io/documentation/operators/delay.html">ReactiveX operators documentation: Delay</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Single<T> delay(long delay, TimeUnit unit) {
         return delay(delay, unit, Schedulers.computation());
     }
@@ -2495,9 +2482,8 @@ public final Single<T> delay(long delay, TimeUnit unit) {
      * @return a {@link Single} whose {@link Observer}s' subscriptions trigger an invocation of the given
      *         {@link Single} factory function.
      * @see <a href="http://reactivex.io/documentation/operators/defer.html">ReactiveX operators documentation: Defer</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T> Single<T> defer(final Callable<Single<T>> singleFactory) {
         return create(new OnSubscribe<T>() {
             @Override
@@ -2531,9 +2517,8 @@ public void call(SingleSubscriber<? super T> singleSubscriber) {
      *            the action that gets called when this {@link Single} is unsubscribed.
      * @return the source {@link Single} modified so as to call this Action when appropriate.
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Single<T> doOnUnsubscribe(final Action0 action) {
         return create(new SingleDoOnUnsubscribe<T>(onSubscribe, action));
     }
@@ -2553,9 +2538,8 @@ public final Single<T> doOnUnsubscribe(final Action0 action) {
      * @return a {@link Single} that emits the same item or error as the source {@link Single}, then invokes the
      *         {@link Action0}
      * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Single<T> doAfterTerminate(Action0 action) {
         return create(new SingleDoAfterTerminate<T>(this, action));
     }
@@ -2735,8 +2719,8 @@ public final Single<T> retryWhen(final Func1<Observable<? extends Throwable>, ?
      *            the function that will dispose of the resource
      * @return the Single whose lifetime controls the lifetime of the dependent resource object
      * @see <a href="http://reactivex.io/documentation/operators/using.html">ReactiveX operators documentation: Using</a>
+     * @since 1.3
      */
-    @Beta
     public static <T, Resource> Single<T> using(
             final Func0<Resource> resourceFactory,
             final Func1<? super Resource, ? extends Single<? extends T>> singleFactory,
@@ -2770,10 +2754,8 @@ public static <T, Resource> Single<T> using(
      *            a terminal event ({@code onComplete} or {@code onError}).
      * @return the Single whose lifetime controls the lifetime of the dependent resource object
      * @see <a href="http://reactivex.io/documentation/operators/using.html">ReactiveX operators documentation: Using</a>
-     * @Experimental The behavior of this can change at any time.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static <T, Resource> Single<T> using(
             final Func0<Resource> resourceFactory,
             final Func1<? super Resource, ? extends Single<? extends T>> singleFactory,
@@ -2806,9 +2788,8 @@ public static <T, Resource> Single<T> using(
      *        to this Single.
      * @return a Single that delays the subscription to this Single
      *         until the Observable emits an element or completes normally.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public final Single<T> delaySubscription(Observable<?> other) {
         if (other == null) {
             throw new NullPointerException();
@@ -2874,10 +2855,10 @@ public void call() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code test} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>History: 1.2.3 - experimental
      * @return the new AssertableSubscriber instance
-     * @since 1.2.3
+     * @since 1.3
      */
-    @Experimental
     public final AssertableSubscriber<T> test() {
         AssertableSubscriberObservable<T> ts = AssertableSubscriberObservable.create(Long.MAX_VALUE);
         subscribe(ts);
diff --git a/src/main/java/rx/SingleEmitter.java b/src/main/java/rx/SingleEmitter.java
index c4f3d11615..a60d0840a5 100644
--- a/src/main/java/rx/SingleEmitter.java
+++ b/src/main/java/rx/SingleEmitter.java
@@ -15,7 +15,6 @@
  */
 package rx;
 
-import rx.annotations.Experimental;
 import rx.functions.Cancellable;
 
 /**
@@ -24,11 +23,10 @@
  * <p>
  * All methods are thread-safe; calling onSuccess or onError twice or one after the other has
  * no effect.
- * @since 1.2.3 - experimental (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
- * 
+ * <p>History: 1.2.3 - experimental 
  * @param <T> the success value type
+ * @since 1.3
  */
-@Experimental
 public interface SingleEmitter<T> {
 
     /**
diff --git a/src/main/java/rx/exceptions/AssemblyStackTraceException.java b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
index 8342adc637..c21cb94510 100644
--- a/src/main/java/rx/exceptions/AssemblyStackTraceException.java
+++ b/src/main/java/rx/exceptions/AssemblyStackTraceException.java
@@ -17,14 +17,13 @@
 
 import java.util.*;
 
-import rx.annotations.Experimental;
 import rx.plugins.RxJavaHooks;
 
 /**
  * A RuntimeException that is stackless but holds onto a textual
  * stacktrace from tracking the assembly location of operators.
+ * @since 1.3
  */
-@Experimental
 public final class AssemblyStackTraceException extends RuntimeException {
 
     /** */
diff --git a/src/main/java/rx/exceptions/CompositeException.java b/src/main/java/rx/exceptions/CompositeException.java
index cfbfdc2113..855d720e49 100644
--- a/src/main/java/rx/exceptions/CompositeException.java
+++ b/src/main/java/rx/exceptions/CompositeException.java
@@ -18,8 +18,6 @@
 import java.io.*;
 import java.util.*;
 
-import rx.annotations.Beta;
-
 /**
  * Represents an exception that is a composite of one or more other exceptions. A {@code CompositeException}
  * does not modify the structure of any exception it wraps, but at print-time it iterates through the list of
@@ -85,8 +83,8 @@ public CompositeException(Collection<? extends Throwable> errors) {
     /**
      * Constructs a CompositeException instance with the supplied initial Throwables.
      * @param errors the array of Throwables
+     * @since 1.3
      */
-    @Beta
     public CompositeException(Throwable... errors) {
         Set<Throwable> deDupedExceptions = new LinkedHashSet<Throwable>();
         List<Throwable> localExceptions = new ArrayList<Throwable>();
diff --git a/src/main/java/rx/exceptions/Exceptions.java b/src/main/java/rx/exceptions/Exceptions.java
index 276e563e48..9e5f25393d 100644
--- a/src/main/java/rx/exceptions/Exceptions.java
+++ b/src/main/java/rx/exceptions/Exceptions.java
@@ -19,7 +19,6 @@
 
 import rx.Observer;
 import rx.SingleSubscriber;
-import rx.annotations.Beta;
 
 /**
  * Utility class with methods to wrap checked exceptions and
@@ -182,9 +181,8 @@ public static void throwIfAny(List<? extends Throwable> exceptions) {
      * @param t the exception
      * @param o the observer to report to
      * @param value the value that caused the exception
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static void throwOrReport(Throwable t, Observer<?> o, Object value) {
         Exceptions.throwIfFatal(t);
         o.onError(OnErrorThrowable.addValueAsLastCause(t, value));
@@ -196,9 +194,8 @@ public static void throwOrReport(Throwable t, Observer<?> o, Object value) {
      * @param t the exception
      * @param o the observer to report to
      * @param value the value that caused the exception
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static void throwOrReport(Throwable t, SingleSubscriber<?> o, Object value) {
         Exceptions.throwIfFatal(t);
         o.onError(OnErrorThrowable.addValueAsLastCause(t, value));
@@ -208,9 +205,8 @@ public static void throwOrReport(Throwable t, SingleSubscriber<?> o, Object valu
      * Forwards a fatal exception or reports it to the given Observer.
      * @param t the exception
      * @param o the observer to report to
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public static void throwOrReport(Throwable t, Observer<?> o) {
         Exceptions.throwIfFatal(t);
         o.onError(t);
@@ -221,9 +217,8 @@ public static void throwOrReport(Throwable t, Observer<?> o) {
      *
      * @param throwable the exception.
      * @param subscriber the subscriber to report to.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number).
+     * @since 1.3
      */
-    @Beta
     public static void throwOrReport(Throwable throwable, SingleSubscriber<?> subscriber) {
         Exceptions.throwIfFatal(throwable);
         subscriber.onError(throwable);
diff --git a/src/main/java/rx/functions/Cancellable.java b/src/main/java/rx/functions/Cancellable.java
index 1109522d86..7b92b71884 100644
--- a/src/main/java/rx/functions/Cancellable.java
+++ b/src/main/java/rx/functions/Cancellable.java
@@ -16,12 +16,10 @@
 
 package rx.functions;
 
-import rx.annotations.Experimental;
-
 /**
  * A functional interface that has a single close method that can throw.
+ * @since 1.3
  */
-@Experimental
 public interface Cancellable {
 
     /**
diff --git a/src/main/java/rx/internal/observers/AssertableSubscriberObservable.java b/src/main/java/rx/internal/observers/AssertableSubscriberObservable.java
index b9068b04ff..d9081b5a8d 100644
--- a/src/main/java/rx/internal/observers/AssertableSubscriberObservable.java
+++ b/src/main/java/rx/internal/observers/AssertableSubscriberObservable.java
@@ -20,7 +20,6 @@
 
 import rx.Producer;
 import rx.Subscriber;
-import rx.annotations.Experimental;
 import rx.functions.Action0;
 import rx.observers.TestSubscriber;
 import rx.observers.AssertableSubscriber;
@@ -33,8 +32,8 @@
  * 
  * @param <T>
  *            the value type
+ * @since 1.3
  */
-@Experimental
 public class AssertableSubscriberObservable<T> extends Subscriber<T> implements AssertableSubscriber<T> {
 
     private final TestSubscriber<T> ts;
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFlatMapCompletable.java b/src/main/java/rx/internal/operators/OnSubscribeFlatMapCompletable.java
index bfb8d6d69a..8b22e740a0 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFlatMapCompletable.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFlatMapCompletable.java
@@ -27,8 +27,9 @@
 /**
  * Maps upstream values to Completables and merges them, up to a given
  * number of them concurrently, optionally delaying errors.
+ * <p>History: 1.2.7 - experimental
  * @param <T> the upstream value type
- * @since 1.2.7 - experimental
+ * @since 1.3
  */
 public final class OnSubscribeFlatMapCompletable<T> implements Observable.OnSubscribe<T> {
 
diff --git a/src/main/java/rx/internal/operators/OnSubscribeFlatMapSingle.java b/src/main/java/rx/internal/operators/OnSubscribeFlatMapSingle.java
index b64a4ef760..190d6acbc0 100644
--- a/src/main/java/rx/internal/operators/OnSubscribeFlatMapSingle.java
+++ b/src/main/java/rx/internal/operators/OnSubscribeFlatMapSingle.java
@@ -31,9 +31,10 @@
 /**
  * Maps upstream values to Singles and merges them, up to a given
  * number of them concurrently, optionally delaying errors.
+ * <p>History: 1.2.7 - experimental
  * @param <T> the upstream value type
  * @param <R> the inner Singles and result value type
- * @since 1.2.7 - experimental
+ * @since 1.3
  */
 public final class OnSubscribeFlatMapSingle<T, R> implements Observable.OnSubscribe<R> {
 
diff --git a/src/main/java/rx/internal/schedulers/SchedulerWhen.java b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
index 880992c9d5..f35528bb12 100644
--- a/src/main/java/rx/internal/schedulers/SchedulerWhen.java
+++ b/src/main/java/rx/internal/schedulers/SchedulerWhen.java
@@ -26,7 +26,6 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscription;
-import rx.annotations.Experimental;
 import rx.functions.Action0;
 import rx.functions.Func1;
 import rx.internal.operators.BufferUntilSubscriber;
@@ -101,8 +100,8 @@
  *     }));
  * });
  * </pre>
+ * @since 1.3
  */
-@Experimental
 public class SchedulerWhen extends Scheduler implements Subscription {
     private final Scheduler actualScheduler;
     private final Observer<Observable<Completable>> workerObserver;
diff --git a/src/main/java/rx/internal/util/BackpressureDrainManager.java b/src/main/java/rx/internal/util/BackpressureDrainManager.java
index 9fde1e62f7..da31c78178 100644
--- a/src/main/java/rx/internal/util/BackpressureDrainManager.java
+++ b/src/main/java/rx/internal/util/BackpressureDrainManager.java
@@ -18,16 +18,14 @@
 import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Producer;
-import rx.annotations.Experimental;
 
 /**
  * Manages the producer-backpressure-consumer interplay by
  * matching up available elements with requested elements and/or
  * terminal events.
- *
- * @since 1.1.0
+ * <p>History: 1.1.0 - experimental
+ * @since 1.3
  */
-@Experimental
 public final class BackpressureDrainManager extends AtomicLong implements Producer {
     /** */
     private static final long serialVersionUID = 2826241102729529449L;
diff --git a/src/main/java/rx/internal/util/BlockingUtils.java b/src/main/java/rx/internal/util/BlockingUtils.java
index 17b0143e52..cb010af57e 100644
--- a/src/main/java/rx/internal/util/BlockingUtils.java
+++ b/src/main/java/rx/internal/util/BlockingUtils.java
@@ -17,7 +17,6 @@
 package rx.internal.util;
 
 import rx.Subscription;
-import rx.annotations.Experimental;
 
 import java.util.concurrent.CountDownLatch;
 
@@ -25,8 +24,8 @@
  * Utility functions relating to blocking types.
  * <p/>
  * Not intended to be part of the public API.
+ * @since 1.3
  */
-@Experimental
 public final class BlockingUtils {
 
     private BlockingUtils() { }
@@ -37,7 +36,6 @@ private BlockingUtils() { }
      * @param latch        a CountDownLatch
      * @param subscription the Subscription to wait on.
      */
-    @Experimental
     public static void awaitForComplete(CountDownLatch latch, Subscription subscription) {
         if (latch.getCount() == 0) {
             // Synchronous observable completes before awaiting for it.
diff --git a/src/main/java/rx/observables/AsyncOnSubscribe.java b/src/main/java/rx/observables/AsyncOnSubscribe.java
index e3acb1627e..e8d1ff71e6 100644
--- a/src/main/java/rx/observables/AsyncOnSubscribe.java
+++ b/src/main/java/rx/observables/AsyncOnSubscribe.java
@@ -23,7 +23,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
-import rx.annotations.Experimental;
+import rx.annotations.Beta;
 import rx.functions.*;
 import rx.internal.operators.BufferUntilSubscriber;
 import rx.observers.SerializedObserver;
@@ -43,8 +43,9 @@
  *            {@link #onUnsubscribe(Object) onUnsubscribe(S)}.
  * @param <T>
  *            the type of {@code Subscribers} that will be compatible with {@code this}.
+ * @since 1.3 - beta
  */
-@Experimental
+@Beta
 public abstract class AsyncOnSubscribe<S, T> implements OnSubscribe<T> {
 
     /**
@@ -110,7 +111,6 @@ protected void onUnsubscribe(S state) {
      *            {@link #next(Object, long, Observer) next(S, long, Observer)})
      * @return an AsyncOnSubscribe that emits data in a protocol compatible with back-pressure.
      */
-    @Experimental
     public static <S, T> AsyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator,
             final Action3<? super S, Long, ? super Observer<Observable<? extends T>>> next) {
         Func3<S, Long, ? super Observer<Observable<? extends T>>, S> nextFunc =
@@ -141,7 +141,6 @@ public S call(S state, Long requested, Observer<Observable<? extends T>> subscri
      * @return an AsyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
      */
-    @Experimental
     public static <S, T> AsyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator,
             final Action3<? super S, Long, ? super Observer<Observable<? extends T>>> next,
             final Action1<? super S> onUnsubscribe) {
@@ -171,7 +170,6 @@ public S call(S state, Long requested, Observer<Observable<? extends T>> subscri
      * @return an AsyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
      */
-    @Experimental
     public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator,
             Func3<? super S, Long, ? super Observer<Observable<? extends T>>, ? extends S> next,
             Action1<? super S> onUnsubscribe) {
@@ -192,7 +190,6 @@ public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> ge
      * @return an AsyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
      */
-    @Experimental
     public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator,
             Func3<? super S, Long, ? super Observer<Observable<? extends T>>, ? extends S> next) {
         return new AsyncOnSubscribeImpl<S, T>(generator, next);
@@ -212,7 +209,6 @@ public static <S, T> AsyncOnSubscribe<S, T> createStateful(Func0<? extends S> ge
      * @return an AsyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
      */
-    @Experimental
     public static <T> AsyncOnSubscribe<Void, T> createStateless(final Action2<Long, ? super Observer<Observable<? extends T>>> next) {
         Func3<Void, Long, Observer<Observable<? extends T>>, Void> nextFunc =
                 new Func3<Void, Long, Observer<Observable<? extends T>>, Void>() {
@@ -240,7 +236,6 @@ public Void call(Void state, Long requested, Observer<Observable<? extends T>> s
      * @return an AsyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
      */
-    @Experimental
     public static <T> AsyncOnSubscribe<Void, T> createStateless(final Action2<Long, ? super Observer<Observable<? extends T>>> next,
             final Action0 onUnsubscribe) {
         Func3<Void, Long, Observer<Observable<? extends T>>, Void> nextFunc =
diff --git a/src/main/java/rx/observables/BlockingObservable.java b/src/main/java/rx/observables/BlockingObservable.java
index 59cb245415..ebde4486b0 100644
--- a/src/main/java/rx/observables/BlockingObservable.java
+++ b/src/main/java/rx/observables/BlockingObservable.java
@@ -22,7 +22,6 @@
 import rx.*;
 import rx.Observable;
 import rx.Observer;
-import rx.annotations.Beta;
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.internal.operators.*;
@@ -469,9 +468,8 @@ public void onNext(final T item) {
 
     /**
      * Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public void subscribe() {
         final CountDownLatch cdl = new CountDownLatch(1);
         final Throwable[] error = { null };
@@ -503,9 +501,8 @@ public void onCompleted() {
     /**
      * Subscribes to the source and calls back the Observer methods on the current thread.
      * @param observer the observer to call event methods on
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public void subscribe(Observer<? super T> observer) {
         final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();
 
@@ -548,10 +545,9 @@ public void onCompleted() {
      * <p>
      * The unsubscription and backpressure is composed through.
      * @param subscriber the subscriber to forward events and calls to in the current thread
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
     @SuppressWarnings("unchecked")
-    @Beta
     public void subscribe(Subscriber<? super T> subscriber) {
         final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();
         final Producer[] theProducer = { null };
@@ -631,9 +627,8 @@ public void call() {
      *
      * @param onNext the callback action for each source value
      * @see #forEach(Action1)
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public void subscribe(final Action1<? super T> onNext) {
         subscribe(onNext, new Action1<Throwable>() {
             @Override
@@ -647,9 +642,8 @@ public void call(Throwable t) {
      * Subscribes to the source and calls the given actions on the current thread.
      * @param onNext the callback action for each source value
      * @param onError the callback action for an error event
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public void subscribe(final Action1<? super T> onNext, final Action1<? super Throwable> onError) {
         subscribe(onNext, onError, Actions.empty());
     }
@@ -659,9 +653,8 @@ public void subscribe(final Action1<? super T> onNext, final Action1<? super Thr
      * @param onNext the callback action for each source value
      * @param onError the callback action for an error event
      * @param onCompleted the callback action for the completion event.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Beta
     public void subscribe(final Action1<? super T> onNext, final Action1<? super Throwable> onError, final Action0 onCompleted) {
         subscribe(new Observer<T>() {
             @Override
diff --git a/src/main/java/rx/observables/SyncOnSubscribe.java b/src/main/java/rx/observables/SyncOnSubscribe.java
index cf848e7bc4..9d4b5245f4 100644
--- a/src/main/java/rx/observables/SyncOnSubscribe.java
+++ b/src/main/java/rx/observables/SyncOnSubscribe.java
@@ -20,7 +20,6 @@
 
 import rx.*;
 import rx.Observable.OnSubscribe;
-import rx.annotations.Beta;
 import rx.exceptions.Exceptions;
 import rx.functions.*;
 import rx.internal.operators.BackpressureUtils;
@@ -120,8 +119,8 @@ protected void onUnsubscribe(S state) {
      *            produces data to the downstream subscriber (see {@link #next(Object, Observer)
      *            next(S, Subscriber)})
      * @return a SyncOnSubscribe that emits data in a protocol compatible with back-pressure.
+     * @since 1.3
      */
-    @Beta
     public static <S, T> SyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator,
             final Action2<? super S, ? super Observer<? super T>> next) {
         Func2<S, ? super Observer<? super T>, S> nextFunc = new Func2<S, Observer<? super T>, S>() {
@@ -151,8 +150,8 @@ public S call(S state, Observer<? super T> subscriber) {
      *            clean up behavior (see {@link #onUnsubscribe(Object) onUnsubscribe(S)})
      * @return a SyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
+     * @since 1.3
      */
-    @Beta
     public static <S, T> SyncOnSubscribe<S, T> createSingleState(Func0<? extends S> generator,
             final Action2<? super S, ? super Observer<? super T>> next,
             final Action1<? super S> onUnsubscribe) {
@@ -181,8 +180,8 @@ public S call(S state, Observer<? super T> subscriber) {
      *            clean up behavior (see {@link #onUnsubscribe(Object) onUnsubscribe(S)})
      * @return a SyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
+     * @since 1.3
      */
-    @Beta
     public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator,
             Func2<? super S, ? super Observer<? super T>, ? extends S> next,
             Action1<? super S> onUnsubscribe) {
@@ -202,8 +201,8 @@ public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> gen
      *            next(S, Subscriber)})
      * @return a SyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
+     * @since 1.3
      */
-    @Beta
     public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> generator,
             Func2<? super S, ? super Observer<? super T>, ? extends S> next) {
         return new SyncOnSubscribeImpl<S, T>(generator, next);
@@ -222,8 +221,8 @@ public static <S, T> SyncOnSubscribe<S, T> createStateful(Func0<? extends S> gen
      *            next(S, Subscriber)})
      * @return a SyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
+     * @since 1.3
      */
-    @Beta
     public static <T> SyncOnSubscribe<Void, T> createStateless(final Action1<? super Observer<? super T>> next) {
         Func2<Void, Observer<? super T>, Void> nextFunc = new Func2<Void, Observer<? super T>, Void>() {
             @Override
@@ -250,8 +249,8 @@ public Void call(Void state, Observer<? super T> subscriber) {
      *            clean up behavior (see {@link #onUnsubscribe(Object) onUnsubscribe(S)})
      * @return a SyncOnSubscribe that emits data downstream in a protocol compatible with
      *         back-pressure.
+     * @since 1.3
      */
-    @Beta
     public static <T> SyncOnSubscribe<Void, T> createStateless(final Action1<? super Observer<? super T>> next,
             final Action0 onUnsubscribe) {
         Func2<Void, Observer<? super T>, Void> nextFunc = new Func2<Void, Observer<? super T>, Void>() {
diff --git a/src/main/java/rx/observers/AssertableSubscriber.java b/src/main/java/rx/observers/AssertableSubscriber.java
index 756d3049d0..21180c7eb2 100644
--- a/src/main/java/rx/observers/AssertableSubscriber.java
+++ b/src/main/java/rx/observers/AssertableSubscriber.java
@@ -19,7 +19,6 @@
 import java.util.concurrent.TimeUnit;
 
 import rx.*;
-import rx.annotations.Experimental;
 import rx.functions.Action0;
 
 /**
@@ -30,10 +29,10 @@
  * <p>
  * This interface extends {@link Observer} and allows injecting onXXX signals into
  * the testing process.
+ * <p>History: 1.2.3 - experimental
  * @param <T> the value type consumed by this Observer
- * @since 1.2.3
+ * @since 1.3
  */
-@Experimental
 public interface AssertableSubscriber<T> extends Observer<T>, Subscription {
 
     /**
diff --git a/src/main/java/rx/observers/AsyncCompletableSubscriber.java b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
index 28c346da76..81933b80e6 100644
--- a/src/main/java/rx/observers/AsyncCompletableSubscriber.java
+++ b/src/main/java/rx/observers/AsyncCompletableSubscriber.java
@@ -19,7 +19,6 @@
 
 import rx.CompletableSubscriber;
 import rx.Subscription;
-import rx.annotations.Experimental;
 import rx.plugins.RxJavaHooks;
 
 /**
@@ -54,9 +53,8 @@
  *     }
  * }
  * </code></pre>
- * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ * @since 1.3
  */
-@Experimental
 public abstract class AsyncCompletableSubscriber implements CompletableSubscriber, Subscription {
     /**
      * Indicates the unsubscribed state.
diff --git a/src/main/java/rx/observers/SafeCompletableSubscriber.java b/src/main/java/rx/observers/SafeCompletableSubscriber.java
index bc7b35e858..6f96ecfc0d 100644
--- a/src/main/java/rx/observers/SafeCompletableSubscriber.java
+++ b/src/main/java/rx/observers/SafeCompletableSubscriber.java
@@ -17,7 +17,6 @@
 
 import rx.CompletableSubscriber;
 import rx.Subscription;
-import rx.annotations.Experimental;
 import rx.exceptions.*;
 import rx.plugins.RxJavaHooks;
 
@@ -25,9 +24,8 @@
  * Wraps another CompletableSubscriber and handles exceptions thrown
  * from onError and onCompleted.
  *
- * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ * @since 1.3
  */
-@Experimental
 public final class SafeCompletableSubscriber implements CompletableSubscriber, Subscription {
     final CompletableSubscriber actual;
 
diff --git a/src/main/java/rx/observers/TestSubscriber.java b/src/main/java/rx/observers/TestSubscriber.java
index bb76878ba6..6553dcb2bf 100644
--- a/src/main/java/rx/observers/TestSubscriber.java
+++ b/src/main/java/rx/observers/TestSubscriber.java
@@ -20,7 +20,6 @@
 
 import rx.*;
 import rx.Observer;
-import rx.annotations.Experimental;
 import rx.exceptions.CompositeException;
 
 /**
@@ -225,9 +224,8 @@ public List<Notification<T>> getOnCompletedEvents() {
     /**
      * Returns the number of times onCompleted was called on this TestSubscriber.
      * @return the number of times onCompleted was called on this TestSubscriber.
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final int getCompletions() {
         return completions;
     }
@@ -356,9 +354,8 @@ private void assertItem(T expected, int i) {
      * @param unit the time unit of waiting
      * @return true if the expected number of onNext events happened
      * @throws RuntimeException if the sleep is interrupted
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final boolean awaitValueCount(int expected, long timeout, TimeUnit unit) {
         while (timeout != 0 && valueCount < expected) {
             try {
@@ -696,9 +693,8 @@ final void assertionError(String message) {
      * </pre></code>
      * @param expectedFirstValue the expected first value
      * @param expectedRestValues the optional rest values
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public final void assertValuesAndClear(T expectedFirstValue, T... expectedRestValues) {
         int n = 1 + expectedRestValues.length;
         assertValueCount(n);
diff --git a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
index c8303ed779..d759d0d021 100644
--- a/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
+++ b/src/main/java/rx/plugins/RxJavaCompletableExecutionHook.java
@@ -16,7 +16,6 @@
 package rx.plugins;
 
 import rx.*;
-import rx.annotations.Experimental;
 import rx.functions.Func1;
 
 /**
@@ -35,9 +34,8 @@
  * should be fast. If anything time-consuming is to be done it should be spawned asynchronously onto separate
  * worker threads.
  *
- * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ * @since 1.3
  */
-@Experimental
 public abstract class RxJavaCompletableExecutionHook { // NOPMD
     /**
      * Invoked during the construction by {@link Completable#create(Completable.OnSubscribe)}
diff --git a/src/main/java/rx/plugins/RxJavaErrorHandler.java b/src/main/java/rx/plugins/RxJavaErrorHandler.java
index 9324cb9062..4c0dfba9d0 100644
--- a/src/main/java/rx/plugins/RxJavaErrorHandler.java
+++ b/src/main/java/rx/plugins/RxJavaErrorHandler.java
@@ -16,7 +16,6 @@
 package rx.plugins;
 
 import rx.*;
-import rx.annotations.Beta;
 import rx.exceptions.Exceptions;
 
 /**
@@ -64,10 +63,8 @@ public void handleError(Throwable e) {
      *             {@code OnErrorThrowable.OnNextValue}
      * @return a short {@link String} representation of the item if one is known for its type, or null for
      *         default
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the
-     *        release number)
+     * @since 1.3
      */
-    @Beta
     public final String handleOnNextValueRendering(Object item) {
 
         try {
@@ -95,10 +92,8 @@ public final String handleOnNextValueRendering(Object item) {
      * @return a short {@link String} representation of the item if one is known for its type, or null for
      *         default
      * @throws InterruptedException if the rendering thread is interrupted
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the
-     *        release number)
+     * @since 1.3
      */
-    @Beta
     protected String render (Object item) throws InterruptedException {
         //do nothing by default
         return null;
diff --git a/src/main/java/rx/plugins/RxJavaHooks.java b/src/main/java/rx/plugins/RxJavaHooks.java
index 0cac048984..106b9e627f 100644
--- a/src/main/java/rx/plugins/RxJavaHooks.java
+++ b/src/main/java/rx/plugins/RxJavaHooks.java
@@ -19,7 +19,6 @@
 import java.util.concurrent.ScheduledExecutorService;
 
 import rx.*;
-import rx.annotations.Experimental;
 import rx.functions.*;
 import rx.internal.operators.*;
 
@@ -29,8 +28,8 @@
  * <p>
  * The class features a lockdown state, see {@link #lockdown()} and {@link #isLockdown()}, to
  * prevent further changes to the hooks.
+ * @since 1.3
  */
-@Experimental
 public final class RxJavaHooks {
     /**
      * Prevents changing the hook callbacks when set to true.
diff --git a/src/main/java/rx/plugins/RxJavaPlugins.java b/src/main/java/rx/plugins/RxJavaPlugins.java
index 91ba9fa1fa..7a5856d431 100644
--- a/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -17,7 +17,6 @@
 
 import java.util.*;
 import java.util.concurrent.atomic.AtomicReference;
-import rx.annotations.Experimental;
 
 /**
  * Registry for plugin implementations that allows global override and handles the retrieval of correct
@@ -84,9 +83,9 @@ public static RxJavaPlugins getInstance() {
      * during application runtime and also bad code could invoke it in
      * the middle of an application life-cycle and really break applications
      * if not used cautiously. For more detailed discussions:
-     * * @see <a href="https://github.com/ReactiveX/RxJava/issues/2297">Make RxJavaPlugins.reset() public</a>
+     * @see <a href="https://github.com/ReactiveX/RxJava/issues/2297">Make RxJavaPlugins.reset() public</a>
+     * @since 1.3
      */
-    @Experimental
     public void reset() {
         INSTANCE.errorHandler.set(null);
         INSTANCE.observableExecutionHook.set(null);
@@ -228,9 +227,8 @@ public void registerSingleExecutionHook(RxJavaSingleExecutionHook impl) {
      * full class name to load.
      *
      * @return {@link RxJavaCompletableExecutionHook} implementation to use
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public RxJavaCompletableExecutionHook getCompletableExecutionHook() {
         if (completableExecutionHook.get() == null) {
             // check for an implementation from System.getProperty first
@@ -256,9 +254,8 @@ public RxJavaCompletableExecutionHook getCompletableExecutionHook() {
      * @throws IllegalStateException
      *             if called more than once or after the default was initialized (if usage occurs before trying
      *             to register)
-     * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+     * @since 1.3
      */
-    @Experimental
     public void registerCompletableExecutionHook(RxJavaCompletableExecutionHook impl) {
         if (!completableExecutionHook.compareAndSet(null, impl)) {
             throw new IllegalStateException("Another strategy was already registered: " + singleExecutionHook.get());
diff --git a/src/main/java/rx/plugins/RxJavaSchedulersHook.java b/src/main/java/rx/plugins/RxJavaSchedulersHook.java
index cc1675f322..e65ab1f3bc 100644
--- a/src/main/java/rx/plugins/RxJavaSchedulersHook.java
+++ b/src/main/java/rx/plugins/RxJavaSchedulersHook.java
@@ -18,7 +18,6 @@
 
 import java.util.concurrent.ThreadFactory;
 import rx.Scheduler;
-import rx.annotations.Experimental;
 import rx.functions.Action0;
 import rx.internal.schedulers.CachedThreadScheduler;
 import rx.internal.schedulers.EventLoopsScheduler;
@@ -47,8 +46,8 @@ public class RxJavaSchedulersHook {
     /**
      * Create an instance of the default {@link Scheduler} used for {@link Schedulers#computation()}.
      * @return the created Scheduler instance
+     * @since 1.3
      */
-    @Experimental
     public static Scheduler createComputationScheduler() {
         return createComputationScheduler(new RxThreadFactory("RxComputationScheduler-"));
     }
@@ -58,8 +57,8 @@ public static Scheduler createComputationScheduler() {
      * except using {@code threadFactory} for thread creation.
      * @param threadFactory the factory to use for each worker thread
      * @return the created Scheduler instance
+     * @since 1.3
      */
-    @Experimental
     public static Scheduler createComputationScheduler(ThreadFactory threadFactory) {
         if (threadFactory == null) {
             throw new NullPointerException("threadFactory == null");
@@ -70,8 +69,8 @@ public static Scheduler createComputationScheduler(ThreadFactory threadFactory)
     /**
      * Create an instance of the default {@link Scheduler} used for {@link Schedulers#io()}.
      * @return the created Scheduler instance
+     * @since 1.3
      */
-    @Experimental
     public static Scheduler createIoScheduler() {
         return createIoScheduler(new RxThreadFactory("RxIoScheduler-"));
     }
@@ -81,8 +80,8 @@ public static Scheduler createIoScheduler() {
      * except using {@code threadFactory} for thread creation.
      * @param threadFactory the factory to use for each worker thread
      * @return the created Scheduler instance
+     * @since 1.3
      */
-    @Experimental
     public static Scheduler createIoScheduler(ThreadFactory threadFactory) {
         if (threadFactory == null) {
             throw new NullPointerException("threadFactory == null");
@@ -93,8 +92,8 @@ public static Scheduler createIoScheduler(ThreadFactory threadFactory) {
     /**
      * Create an instance of the default {@link Scheduler} used for {@link Schedulers#newThread()}.
      * @return the created Scheduler instance
+     * @since 1.3
      */
-    @Experimental
     public static Scheduler createNewThreadScheduler() {
         return createNewThreadScheduler(new RxThreadFactory("RxNewThreadScheduler-"));
     }
@@ -104,8 +103,8 @@ public static Scheduler createNewThreadScheduler() {
      * except using {@code threadFactory} for thread creation.
      * @param threadFactory the factory to use for each worker thread
      * @return the created Scheduler instance
+     * @since 1.3
      */
-    @Experimental
     public static Scheduler createNewThreadScheduler(ThreadFactory threadFactory) {
         if (threadFactory == null) {
             throw new NullPointerException("threadFactory == null");
diff --git a/src/main/java/rx/schedulers/Schedulers.java b/src/main/java/rx/schedulers/Schedulers.java
index e6435965e5..1327c6ba93 100644
--- a/src/main/java/rx/schedulers/Schedulers.java
+++ b/src/main/java/rx/schedulers/Schedulers.java
@@ -19,7 +19,6 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Scheduler;
-import rx.annotations.Experimental;
 import rx.internal.schedulers.*;
 import rx.plugins.*;
 
@@ -185,8 +184,8 @@ public static Scheduler from(Executor executor) {
      * Resets the current {@link Schedulers} instance.
      * This will re-init the cached schedulers on the next usage,
      * which can be useful in testing.
+     * @since 1.3
      */
-    @Experimental
     public static void reset() {
         Schedulers s = INSTANCE.getAndSet(null);
         if (s != null) {
diff --git a/src/main/java/rx/singles/BlockingSingle.java b/src/main/java/rx/singles/BlockingSingle.java
index 470c012cdb..a113f272ba 100644
--- a/src/main/java/rx/singles/BlockingSingle.java
+++ b/src/main/java/rx/singles/BlockingSingle.java
@@ -20,7 +20,6 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.*;
-import rx.annotations.*;
 import rx.exceptions.Exceptions;
 import rx.internal.operators.BlockingOperatorToFuture;
 import rx.internal.util.BlockingUtils;
@@ -33,9 +32,8 @@
  * or {@link Single#toBlocking()}.
  *
  * @param <T> the value type of the sequence
- * @since (if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
+ * @since 1.3
  */
-@Beta
 public final class BlockingSingle<T> {
     private final Single<? extends T> single;
 
diff --git a/src/main/java/rx/subjects/UnicastSubject.java b/src/main/java/rx/subjects/UnicastSubject.java
index 1c51fe48bb..e7addc5cd8 100644
--- a/src/main/java/rx/subjects/UnicastSubject.java
+++ b/src/main/java/rx/subjects/UnicastSubject.java
@@ -19,7 +19,6 @@
 import java.util.concurrent.atomic.*;
 
 import rx.*;
-import rx.annotations.Experimental;
 import rx.exceptions.*;
 import rx.functions.Action0;
 import rx.internal.operators.*;
@@ -35,8 +34,8 @@
  * <p>
  * <img width="640" height="370" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/UnicastSubject.v1.png" alt="">
  * @param <T> the input and output value type
+ * @since 1.3
  */
-@Experimental
 public final class UnicastSubject<T> extends Subject<T, T> {
 
     final State<T> state;

From daf1022ce86291791817b1ef0f45445445e9a15e Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 5 May 2017 09:49:16 +0200
Subject: [PATCH 236/263] Release 1.3.0

---
 CHANGES.md | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index b02e08b281..6517018463 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,56 @@
 # RxJava Releases #
 
+### Version 1.3.0 - May 5, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.0%7C))
+
+#### Summary
+
+Version 1.3.0 is the next minor release of the 1.x series of RxJava containing many formerly experimental API components promoted to standard. Most notably the `Completable` base reactive type is now standard as well.
+
+Note that the experimental `rx.Observable.fromEmitter()` has been removed in favor for the now also standard `Observable.create(Action1<Emitter<T>> emitter, Emitter.BackpressureMode backpressure)`
+
+The planned lifecycle of the 1.x line is as follows:
+
+Date | Remark
+------------|-------------------
+ **June 1, 2017** | Feature freeze, only bugfixes from this on.
+ **September 1, 2017** | Release `1.4.0` finalizing the remaining API components. 
+ **March 31, 2018** | End of development. 
+
+The following components have been promoted to standard:
+
+**Classes, interfaces**
+
+- **classes**: `AssemblyStackTraceException`, `RxJavaCompletableExecutionHook`, `RxJavaHooks`, `UnicastSubject`, `BlockingSingle`, `Completable`, `AssertableSubscriber`, `AsyncCompletableSubscriber`, `SafeCompletableSubscriber`
+- **interfaces**: `Cancellable`, `Emitter`, `SingleEmitter`, `CompletableEmitter`, `CompletableSubscriber`, `BackpressureOverflow.Strategy`
+
+**Operators**
+
+- **`Observable`**: `create`, `unsafeCreate`, `to`, `zip(Observable[], FuncN)`, `flatMapCompletable`, `flatMapSingle`, `groupby(Func1, Func1, Func1<Action1<K>, Map<K, Object>>)`, `onTerminateDetach`, `rebatchRequests`, `subscribeOn(Scheduler, boolean)`, `sorted`, `withLatestFrom`, `test`, `toCompletable`, `concatDelayError`, `mergeDelayError`, `switchOnNextDelayError`, `using(Func0, Func1, Action1, boolean)`, `concatMapDelayError`, `delaySubscription(Observable)`, `distinctUntilChanged(Func2)`, `concatEager`, `concatMapEager`, `onBackpressureBuffer(long, Action0, BackpressureOverflow.Strategy)`, `switchMapDelayError`, `toSortedList(int)`, `toSortedList(Func2, int)`
+- **`Completable`**: `fromEmitter`, `test`
+- **`Single`**: `fromEmitter`, `merge`, `mergeDelayError`, `cache`, `to`, `doOnEach`, `doOnSuccess`, `test`, `onErrorResumeNext`, `toCompletable`, `doOnError`, `doOnSubscribe`, `delay`, `defer`, `doOnUnsubscribe`, `doAfterTerminate`, `flatMapCompletable`, `lift`, `toBlocking`, `using`, `delaySubscription(Observable)`
+- **`TestSubscriber`**: `getCompletions`, `awaitValueCount`, `assertValuesAndClear`
+- **`SyncOnSubscriber`**: `createSingleState`, `createStateful`, `createStateless`
+
+**Other**
+
+- `Schedulers.reset`
+- `CompositeException(Throwable...)` constructor
+- `Exceptions.throwOrReport` (4 overloads)
+- `BlockingObservable.subscribe` (6 overloads)
+- **`RxJavaSchedulersHook`**: `createComputationScheduler`, `createIoScheduler`, `createNewThreadScheduler`
+- **internal**: `AssertableSubscriberObservable`, `FlatMapCompletable`, `FlatMapSingle`, `SchedulerWhen`, `BackpressureDrainManager`, `BlockingUtils`.
+- **`RxJavaPlugins`**: `reset`, `getCompletableExecutionHook`, `registerCompletableExecutionHook`
+- **`RxJavaErrorHandler`**: `handleOnNextValueRendering`, `render`
+
+In addition, the class `AsyncOnsubscribe` with its 7 factory methods and `Observable.create(AsyncOnSubscribe<S, T>)` have been promoted to **beta**.
+
+#### Acknowledgements
+
+Thanks to all who contributed to the 1.x line in the past 6 months (in order they appear on the [commit](https://github.com/ReactiveX/RxJava/commits/1.x) page):
+
+@mtiidla, @dhendry, @mostroverkhov, @yshrsmz, @BraisGabin, @cesar1000, @Jawnnypoo, @chanx2, @abersnaze, @davidmoten, @ortex, @marwinxxii, @ekchang, @pyricau, @JakeWharton, @VictorAlbertos
+
+
 ### Version 1.2.10 - April 26, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.2.10%7C))
 
 #### Bugfixes

From a5c0cd0359fa2a697435f9c41b76bc0f6d6b1888 Mon Sep 17 00:00:00 2001
From: Michael Burns <Inferno23@users.noreply.github.com>
Date: Mon, 8 May 2017 17:10:26 -0400
Subject: [PATCH 237/263] Add the cast operator to Single. (#5332)

* Add the cast operator to Single.

Signed-off-by: Mike Burns <burnsm523@gmail.com>

* Create a separate operator for Single.cast and test it.

Signed-off-by: Inferno23 <burnsm523@gmail.com>

* Update spacing and javadoc.

Signed-off-by: Inferno23 <burnsm523@gmail.com>

* Add missing @Experimental annotation.

Signed-off-by: Inferno23 <burnsm523@gmail.com>

* Fix the copyrights.

Signed-off-by: Inferno23 <burnsm523@gmail.com>

* Remove extra verify call.

Signed-off-by: Inferno23 <burnsm523@gmail.com>
---
 src/main/java/rx/Single.java                  | 17 +++++++
 .../operators/SingleOperatorCast.java         | 37 ++++++++++++++
 .../operators/SingleOperatorCastTest.java     | 51 +++++++++++++++++++
 3 files changed, 105 insertions(+)
 create mode 100644 src/main/java/rx/internal/operators/SingleOperatorCast.java
 create mode 100644 src/test/java/rx/internal/operators/SingleOperatorCastTest.java

diff --git a/src/main/java/rx/Single.java b/src/main/java/rx/Single.java
index a9bff5e388..0cf0d5f06f 100644
--- a/src/main/java/rx/Single.java
+++ b/src/main/java/rx/Single.java
@@ -210,6 +210,23 @@ private static <T> Observable<T> asObservable(Single<T> t) {
      * *********************************************************************************************************
      */
 
+    /**
+     * Casts the success value of the current Single into the target type or signals a
+     * ClassCastException if not compatible.
+     * <dl>
+     * <dt><b>Scheduler:</b></dt>
+     * <dd>{@code cast} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * @param <R> the target type
+     * @param klass the type token to use for casting the success result from the current Single
+     * @return the new Single instance
+     * @since 1.3.1 - experimental
+     */
+    @Experimental
+    public final <R> Single<R> cast(final Class<R> klass) {
+        return map(new SingleOperatorCast<T, R>(klass));
+    }
+
     /**
      * Returns an Observable that emits the items emitted by two Singles, one after the other.
      * <p>
diff --git a/src/main/java/rx/internal/operators/SingleOperatorCast.java b/src/main/java/rx/internal/operators/SingleOperatorCast.java
new file mode 100644
index 0000000000..b77381b161
--- /dev/null
+++ b/src/main/java/rx/internal/operators/SingleOperatorCast.java
@@ -0,0 +1,37 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import rx.functions.Func1;
+
+/**
+ * Converts the element of a Single to the specified type.
+ * @param <T> the input value type
+ * @param <R> the output value type
+ */
+public class SingleOperatorCast<T, R> implements Func1<T, R> {
+
+    final Class<R> castClass;
+
+    public SingleOperatorCast(Class<R> castClass) {
+        this.castClass = castClass;
+    }
+
+    @Override
+    public R call(T t) {
+        return castClass.cast(t);
+    }
+}
diff --git a/src/test/java/rx/internal/operators/SingleOperatorCastTest.java b/src/test/java/rx/internal/operators/SingleOperatorCastTest.java
new file mode 100644
index 0000000000..48d19045f5
--- /dev/null
+++ b/src/test/java/rx/internal/operators/SingleOperatorCastTest.java
@@ -0,0 +1,51 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+;
+import org.junit.Test;
+import rx.Observer;
+import rx.Single;
+
+import static org.mockito.Mockito.*;
+
+public class SingleOperatorCastTest {
+
+    @Test
+    public void testSingleCast() {
+        Single<?> source = Single.just(1);
+        Single<Integer> single = source.cast(Integer.class);
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = mock(Observer.class);
+        single.subscribe(observer);
+        verify(observer, times(1)).onNext(1);
+        verify(observer, never()).onError(
+            org.mockito.Matchers.any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSingleCastWithWrongType() {
+        Single<?> source = Single.just(1);
+        Single<Boolean> single = source.cast(Boolean.class);
+
+        @SuppressWarnings("unchecked")
+        Observer<Boolean> observer = mock(Observer.class);
+        single.subscribe(observer);
+        verify(observer, times(1)).onError(
+            org.mockito.Matchers.any(ClassCastException.class));
+    }
+}

From 433b099c2d97cc24a2e7d2041755bbe5a8ddd5a0 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Thu, 18 May 2017 17:53:34 +1000
Subject: [PATCH 238/263] remove semicolon that Eclipse thinks is compile error
 (#5353)

---
 src/test/java/rx/internal/operators/SingleOperatorCastTest.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/test/java/rx/internal/operators/SingleOperatorCastTest.java b/src/test/java/rx/internal/operators/SingleOperatorCastTest.java
index 48d19045f5..6d60c8b411 100644
--- a/src/test/java/rx/internal/operators/SingleOperatorCastTest.java
+++ b/src/test/java/rx/internal/operators/SingleOperatorCastTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 package rx.internal.operators;
-;
+
 import org.junit.Test;
 import rx.Observer;
 import rx.Single;

From 1dd023f073548f977ea8d199fa2151279078a340 Mon Sep 17 00:00:00 2001
From: yurgis <yurgis.baykshtis@clarivate.com>
Date: Fri, 23 Jun 2017 02:16:13 -0700
Subject: [PATCH 239/263] fix for
 https://github.com/ReactiveX/RxJava/issues/5429 (#5430)

---
 .../java/rx/observables/AsyncOnSubscribe.java |  7 ++--
 .../rx/observables/AsyncOnSubscribeTest.java  | 34 +++++++++++++++++++
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/src/main/java/rx/observables/AsyncOnSubscribe.java b/src/main/java/rx/observables/AsyncOnSubscribe.java
index e8d1ff71e6..108c9a4c8e 100644
--- a/src/main/java/rx/observables/AsyncOnSubscribe.java
+++ b/src/main/java/rx/observables/AsyncOnSubscribe.java
@@ -532,8 +532,11 @@ boolean tryEmit(long n) {
                 onNextCalled = false;
                 expectedDelivery = n;
                 nextIteration(n);
-
-                if (hasTerminated || isUnsubscribed()) {
+                
+                //hasTerminated will be true when onCompleted was already emitted from the request callback 
+                //even if the the observer has not seen onCompleted from the requested observable, 
+                //so we should not clean up while there are active subscriptions
+                if (hasTerminated && !subscriptions.hasSubscriptions() || isUnsubscribed()) {
                     cleanup();
                     return true;
                 }
diff --git a/src/test/java/rx/observables/AsyncOnSubscribeTest.java b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
index d344532aae..72afaad285 100644
--- a/src/test/java/rx/observables/AsyncOnSubscribeTest.java
+++ b/src/test/java/rx/observables/AsyncOnSubscribeTest.java
@@ -483,4 +483,38 @@ public Integer call(Integer state, Long requested, Observer<Observable<? extends
 
         subscriber.assertNotCompleted();
     }
+
+    @Test
+    public void testMergeDelayedWithScalar() {
+        final TestScheduler scheduler = new TestScheduler();
+        Observable<Integer> os = Observable.create(AsyncOnSubscribe.<Integer, Integer> createStateful(
+            new Func0<Integer>() {
+
+                @Override
+                public Integer call() {
+                    return 0;
+                }
+
+            },
+            new Func3<Integer, Long, Observer<Observable<? extends Integer>>, Integer>() {
+
+                @Override
+                public Integer call(Integer state, Long requested, Observer<Observable<? extends Integer>> emitter) {
+                    if (state == 0) {
+                        emitter.onNext(Observable.range(0,100).delay(1, TimeUnit.SECONDS, scheduler));
+                    } else {
+                        emitter.onCompleted();
+                    }
+                    return state + 1;
+                }
+
+            }));
+
+        TestSubscriber<Object> ts = new TestSubscriber<Object>();
+        os.mergeWith(Observable.just(0)).subscribe(ts);
+        scheduler.advanceTimeBy(1, TimeUnit.HOURS);
+        ts.assertCompleted();
+        ts.assertValueCount(101);
+    }
+
 }
\ No newline at end of file

From 3e5b117fbfd8ef5fecc7869b84e7f6c794b1d399 Mon Sep 17 00:00:00 2001
From: Matt Laux <mlaux@users.noreply.github.com>
Date: Sat, 24 Jun 2017 07:34:48 -0400
Subject: [PATCH 240/263] 1.x: TestSubscriber::assertValuesAndClear should
 reset valueCount (#5437)

---
 src/main/java/rx/observers/TestSubscriber.java        |  1 +
 .../java/rx/observers/AssertableSubscriberTest.java   |  2 +-
 src/test/java/rx/observers/TestSubscriberTest.java    | 11 +++++++++++
 3 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/main/java/rx/observers/TestSubscriber.java b/src/main/java/rx/observers/TestSubscriber.java
index 6553dcb2bf..d35602f572 100644
--- a/src/main/java/rx/observers/TestSubscriber.java
+++ b/src/main/java/rx/observers/TestSubscriber.java
@@ -703,5 +703,6 @@ public final void assertValuesAndClear(T expectedFirstValue, T... expectedRestVa
             assertItem(expectedRestValues[i], i + 1);
         }
         values.clear();
+        valueCount = 0;
     }
 }
diff --git a/src/test/java/rx/observers/AssertableSubscriberTest.java b/src/test/java/rx/observers/AssertableSubscriberTest.java
index 838f57d6ec..4c6adbb06d 100644
--- a/src/test/java/rx/observers/AssertableSubscriberTest.java
+++ b/src/test/java/rx/observers/AssertableSubscriberTest.java
@@ -151,7 +151,7 @@ public void testSingle() {
        assertEquals(Thread.currentThread().getName(), ts.getLastSeenThread().getName());
        assertTrue(ts.getOnErrorEvents().isEmpty());
        assertTrue(ts.getOnNextEvents().isEmpty());
-       assertEquals(1, ts.getValueCount());
+       assertEquals(0, ts.getValueCount());
     }
 
     @Test
diff --git a/src/test/java/rx/observers/TestSubscriberTest.java b/src/test/java/rx/observers/TestSubscriberTest.java
index 5e2c8edc07..a78890aa74 100644
--- a/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/src/test/java/rx/observers/TestSubscriberTest.java
@@ -815,4 +815,15 @@ public void assertAndConsume() {
 
         ts.assertNoValues();
     }
+
+    @Test
+    public void assertAndClearResetsValueCount() {
+        TestSubscriber<Integer> ts = TestSubscriber.create();
+
+        ts.onNext(1);
+        ts.assertValuesAndClear(1);
+
+        ts.assertNoValues();
+        Assert.assertEquals(0, ts.getValueCount());
+    }
 }

From b8f3cedefb350091d3daf53aa3dfabe2da5ae17d Mon Sep 17 00:00:00 2001
From: Gene Taylor <gene.t.taylor@gmail.com>
Date: Thu, 6 Jul 2017 19:54:00 +1000
Subject: [PATCH 241/263] fix #5468: eager hooks onError call (#5470)

* fix #5468: eager hooks onError call

Move the call to RxJavaHooks into the catch block, so we only report it if the underlying subscriber throws in its onError method.
This brings the behaviour in line with that of SafeSubscriber, which only call Hooks.onError inside the catch

*  #5468 move hooks OnError into correct if block
---
 src/main/java/rx/observers/SafeCompletableSubscriber.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/rx/observers/SafeCompletableSubscriber.java b/src/main/java/rx/observers/SafeCompletableSubscriber.java
index 6f96ecfc0d..7430fa371a 100644
--- a/src/main/java/rx/observers/SafeCompletableSubscriber.java
+++ b/src/main/java/rx/observers/SafeCompletableSubscriber.java
@@ -54,8 +54,8 @@ public void onCompleted() {
 
     @Override
     public void onError(Throwable e) {
-        RxJavaHooks.onError(e);
         if (done) {
+            RxJavaHooks.onError(e);
             return;
         }
         done = true;

From 8e925345814c291e2ab2f10f4986f1ac9b8ee68a Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 6 Jul 2017 22:23:10 +0200
Subject: [PATCH 242/263] 1.x: increase timeout of some tests (#5471)

* 1.x: increase timeout of some tests

* OperatorFlatMapTest.flatMapRangeMixedAsyncLoop more time

* Retry testNoBufferingOrBlockingOfSequence multiple times
---
 src/main/java/rx/SingleEmitter.java           |   2 +-
 .../java/rx/observables/AsyncOnSubscribe.java |   6 +-
 .../operators/BlockingOperatorNextTest.java   | 105 ++++++++++--------
 .../operators/CompletableOnErrorXTest.java    |   4 +-
 .../operators/OperatorFlatMapTest.java        |   2 +-
 .../OperatorMergeMaxConcurrentTest.java       |   6 +-
 .../operators/OperatorSwitchTest.java         |   2 +-
 7 files changed, 69 insertions(+), 58 deletions(-)

diff --git a/src/main/java/rx/SingleEmitter.java b/src/main/java/rx/SingleEmitter.java
index a60d0840a5..53d034a076 100644
--- a/src/main/java/rx/SingleEmitter.java
+++ b/src/main/java/rx/SingleEmitter.java
@@ -23,7 +23,7 @@
  * <p>
  * All methods are thread-safe; calling onSuccess or onError twice or one after the other has
  * no effect.
- * <p>History: 1.2.3 - experimental 
+ * <p>History: 1.2.3 - experimental
  * @param <T> the success value type
  * @since 1.3
  */
diff --git a/src/main/java/rx/observables/AsyncOnSubscribe.java b/src/main/java/rx/observables/AsyncOnSubscribe.java
index 108c9a4c8e..7a1eef7112 100644
--- a/src/main/java/rx/observables/AsyncOnSubscribe.java
+++ b/src/main/java/rx/observables/AsyncOnSubscribe.java
@@ -532,9 +532,9 @@ boolean tryEmit(long n) {
                 onNextCalled = false;
                 expectedDelivery = n;
                 nextIteration(n);
-                
-                //hasTerminated will be true when onCompleted was already emitted from the request callback 
-                //even if the the observer has not seen onCompleted from the requested observable, 
+
+                //hasTerminated will be true when onCompleted was already emitted from the request callback
+                //even if the the observer has not seen onCompleted from the requested observable,
                 //so we should not clean up while there are active subscriptions
                 if (hasTerminated && !subscriptions.hasSubscriptions() || isUnsubscribed()) {
                     cleanup();
diff --git a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
index 4cff913cea..69541f712b 100644
--- a/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
+++ b/src/test/java/rx/internal/operators/BlockingOperatorNextTest.java
@@ -234,69 +234,80 @@ public void testNextWithCallingHasNextMultipleTimes() {
      */
     @Test
     public void testNoBufferingOrBlockingOfSequence() throws Throwable {
-        final CountDownLatch finished = new CountDownLatch(1);
-        final int COUNT = 30;
-        final CountDownLatch timeHasPassed = new CountDownLatch(COUNT);
-        final AtomicBoolean running = new AtomicBoolean(true);
-        final AtomicInteger count = new AtomicInteger(0);
-        final Observable<Integer> obs = Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
+        int retries = 10;
 
-            @Override
-            public void call(final Subscriber<? super Integer> o) {
-                new Thread(new Runnable() {
+        for (;;) {
+            try {
+                final CountDownLatch finished = new CountDownLatch(1);
+                final int COUNT = 30;
+                final CountDownLatch timeHasPassed = new CountDownLatch(COUNT);
+                final AtomicBoolean running = new AtomicBoolean(true);
+                final AtomicInteger count = new AtomicInteger(0);
+                final Observable<Integer> obs = Observable.unsafeCreate(new Observable.OnSubscribe<Integer>() {
 
                     @Override
-                    public void run() {
-                        try {
-                            while (running.get()) {
-                                o.onNext(count.incrementAndGet());
-                                timeHasPassed.countDown();
+                    public void call(final Subscriber<? super Integer> o) {
+                        new Thread(new Runnable() {
+
+                            @Override
+                            public void run() {
+                                try {
+                                    while (running.get()) {
+                                        o.onNext(count.incrementAndGet());
+                                        timeHasPassed.countDown();
+                                    }
+                                    o.onCompleted();
+                                } catch (Throwable e) {
+                                    o.onError(e);
+                                } finally {
+                                    finished.countDown();
+                                }
                             }
-                            o.onCompleted();
-                        } catch (Throwable e) {
-                            o.onError(e);
-                        } finally {
-                            finished.countDown();
-                        }
+                        }).start();
                     }
-                }).start();
-            }
 
-        });
+                });
 
-        try {
-            Iterator<Integer> it = next(obs).iterator();
+                try {
+                    Iterator<Integer> it = next(obs).iterator();
 
-            assertTrue(it.hasNext());
-            int a = it.next();
-            assertTrue(it.hasNext());
-            int b = it.next();
-            // we should have a different value
-            assertTrue("a and b should be different", a != b);
+                    assertTrue(it.hasNext());
+                    int a = it.next();
+                    assertTrue(it.hasNext());
+                    int b = it.next();
+                    // we should have a different value
+                    assertTrue("a and b should be different", a != b);
 
-            // wait for some time (if times out we are blocked somewhere so fail ... set very high for very slow, constrained machines)
-            timeHasPassed.await(8000, TimeUnit.MILLISECONDS);
+                    // wait for some time (if times out we are blocked somewhere so fail ... set very high for very slow, constrained machines)
+                    timeHasPassed.await(8000, TimeUnit.MILLISECONDS);
 
-            assertTrue(it.hasNext());
-            int c = it.next();
+                    assertTrue(it.hasNext());
+                    int c = it.next();
 
-            assertTrue("c should not just be the next in sequence", c != (b + 1));
-            assertTrue("expected that c [" + c + "] is higher than or equal to " + COUNT, c >= COUNT);
+                    assertTrue("c should not just be the next in sequence", c != (b + 1));
+                    assertTrue("expected that c [" + c + "] is higher than or equal to " + COUNT, c >= COUNT);
 
-            assertTrue(it.hasNext());
-            int d = it.next();
-            assertTrue(d > c);
+                    assertTrue(it.hasNext());
+                    int d = it.next();
+                    assertTrue(d > c);
 
-            // shut down the thread
-            running.set(false);
+                    // shut down the thread
+                    running.set(false);
 
-            finished.await();
+                    finished.await();
 
-            assertFalse(it.hasNext());
+                    assertFalse(it.hasNext());
 
-            System.out.println("a: " + a + " b: " + b + " c: " + c);
-        } finally {
-            running.set(false); // don't let the thread spin indefinitely
+                    System.out.println("a: " + a + " b: " + b + " c: " + c);
+                } finally {
+                    running.set(false); // don't let the thread spin indefinitely
+                }
+                return;
+            } catch (AssertionError ex) {
+                if (retries-- == 0) {
+                    throw ex;
+                }
+            }
         }
     }
 
diff --git a/src/test/java/rx/internal/operators/CompletableOnErrorXTest.java b/src/test/java/rx/internal/operators/CompletableOnErrorXTest.java
index c462352af3..31cbff9df1 100644
--- a/src/test/java/rx/internal/operators/CompletableOnErrorXTest.java
+++ b/src/test/java/rx/internal/operators/CompletableOnErrorXTest.java
@@ -29,7 +29,7 @@ public class CompletableOnErrorXTest {
     @Test
     public void nextUnsubscribe() {
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         AssertableSubscriber<Void> as = ps.toCompletable()
         .onErrorResumeNext(new Func1<Throwable, Completable>() {
             @Override
@@ -49,7 +49,7 @@ public Completable call(Throwable e) {
     @Test
     public void completeUnsubscribe() {
         PublishSubject<Integer> ps = PublishSubject.create();
-        
+
         AssertableSubscriber<Void> as = ps.toCompletable()
         .onErrorComplete()
         .test();
diff --git a/src/test/java/rx/internal/operators/OperatorFlatMapTest.java b/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
index 61805d7372..286a2a03bc 100644
--- a/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
+++ b/src/test/java/rx/internal/operators/OperatorFlatMapTest.java
@@ -468,7 +468,7 @@ public Observable<Integer> call(Integer t) {
             }
         }
     }
-    @Test(timeout = 30000)
+    @Test(timeout = 60000)
     public void flatMapRangeMixedAsyncLoop() {
         for (int i = 0; i < 2000; i++) {
             if (i % 10 == 0) {
diff --git a/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java b/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
index 21ce364b34..5be03a3b6f 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeMaxConcurrentTest.java
@@ -197,7 +197,7 @@ public void testSimpleAsyncLoop() {
             testSimpleAsync();
         }
     }
-    @Test(timeout = 10000)
+    @Test(timeout = 30000)
     public void testSimpleAsync() {
         for (int i = 1; i < 50; i++) {
             TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
@@ -217,7 +217,7 @@ public void testSimpleAsync() {
             assertEquals(expected, actual);
         }
     }
-    @Test(timeout = 10000)
+    @Test(timeout = 30000)
     public void testSimpleOneLessAsyncLoop() {
         int max = 200;
         if (PlatformDependent.isAndroid()) {
@@ -227,7 +227,7 @@ public void testSimpleOneLessAsyncLoop() {
             testSimpleOneLessAsync();
         }
     }
-    @Test(timeout = 10000)
+    @Test(timeout = 30000)
     public void testSimpleOneLessAsync() {
         long t = System.currentTimeMillis();
         for (int i = 2; i < 50; i++) {
diff --git a/src/test/java/rx/internal/operators/OperatorSwitchTest.java b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
index 8525c18cd6..00887db5e1 100644
--- a/src/test/java/rx/internal/operators/OperatorSwitchTest.java
+++ b/src/test/java/rx/internal/operators/OperatorSwitchTest.java
@@ -894,7 +894,7 @@ public void asyncInner() throws Throwable {
             .switchMap(UtilityFunctions.<Observable<Integer>>identity())
             .observeOn(Schedulers.computation())
             .ignoreElements()
-            .timeout(5, TimeUnit.SECONDS)
+            .timeout(15, TimeUnit.SECONDS)
             .toBlocking()
             .subscribe(Actions.empty(), new Action1<Throwable>() {
                 @Override

From 85350bf1465416fbc23a54f465e9b75cb71fd361 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sun, 10 Sep 2017 18:19:29 +0200
Subject: [PATCH 243/263] Update CHANGES.md

---
 CHANGES.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 6517018463..373c3665c9 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,18 @@
 # RxJava Releases #
 
+### Version 1.3.1 - September 10, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.1%7C))
+
+#### API changes
+*Remark: submitted & merged before the feature freeze of June 1st.*
+
+- [Pull 5332](https://github.com/ReactiveX/RxJava/pull/5332): Add the `cast` operator to `Single`.
+
+#### Bugfixes
+
+- [Pull 5430](https://github.com/ReactiveX/RxJava/pull/5430): Fix premature cleanup in `AsyncOnSubscribe` when the last `Observable` is still running.
+- [Pull 5437](https://github.com/ReactiveX/RxJava/pull/5437): `TestSubscriber::assertValuesAndClear` should reset `valueCount`.
+- [Pull 5470](https://github.com/ReactiveX/RxJava/pull/5470): Fix eager call to `RxJavHooks.onError` in `SafeCompletableSuscriber`.
+
 ### Version 1.3.0 - May 5, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.0%7C))
 
 #### Summary

From ed35a14b8b8c5899f292e60905e082563d516539 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sun, 10 Sep 2017 18:21:42 +0200
Subject: [PATCH 244/263] Use oraclejdk8

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index f07cf8d5e4..751937fa52 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,6 @@
 language: java
 jdk:
-- oraclejdk7
+- oraclejdk8
 sudo: false
 # as per http://blog.travis-ci.com/2014-12-17-faster-builds-with-container-based-infrastructure/
 

From 50ea46a344485df787d938a954cf871f36abc44a Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 15 Sep 2017 09:27:06 +0200
Subject: [PATCH 245/263] 1.x: Workaround for CHM.keySet bad type with Java 8
 compiler (#5602)

---
 src/main/java/rx/internal/schedulers/NewThreadWorker.java | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/main/java/rx/internal/schedulers/NewThreadWorker.java b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
index dd63eddf9a..23f8af90e2 100644
--- a/src/main/java/rx/internal/schedulers/NewThreadWorker.java
+++ b/src/main/java/rx/internal/schedulers/NewThreadWorker.java
@@ -16,7 +16,7 @@
 package rx.internal.schedulers;
 
 import java.lang.reflect.*;
-import java.util.Iterator;
+import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -110,10 +110,12 @@ public static void deregisterExecutor(ScheduledExecutorService service) {
     }
 
     /** Purges each registered executor and eagerly evicts shutdown executors. */
-    @SuppressAnimalSniffer // CHM.keySet returns KeySetView in Java 8+; false positive here
     static void purgeExecutors() {
         try {
-            Iterator<ScheduledThreadPoolExecutor> it = EXECUTORS.keySet().iterator();
+            // This prevents map.keySet to compile to a Java 8+ KeySetView return type
+            // and cause NoSuchMethodError on Java 6-7 runtimes.
+            Map<ScheduledThreadPoolExecutor, ScheduledThreadPoolExecutor> map = EXECUTORS;
+            Iterator<ScheduledThreadPoolExecutor> it = map.keySet().iterator();
             while (it.hasNext()) {
                 ScheduledThreadPoolExecutor exec = it.next();
                 if (!exec.isShutdown()) {

From 81542cdc4278c8d4509a66441976d908a2197ea5 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 15 Sep 2017 09:35:00 +0200
Subject: [PATCH 246/263] Release 1.3.2

---
 CHANGES.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 373c3665c9..3a834830b7 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,11 @@
 # RxJava Releases #
 
+### Version 1.3.2 - September 15, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.2%7C))
+
+#### Bugfixes
+
+- [Pull 5602](https://github.com/ReactiveX/RxJava/pull/5602): Workaround for CHM.keySet bad type with Java 8 compiler
+
 ### Version 1.3.1 - September 10, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.1%7C))
 
 #### API changes

From 0660284a9ba53e755c04c407c1dcdd5d4c7fd85b Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Fri, 13 Oct 2017 21:11:12 +0200
Subject: [PATCH 247/263] 1.x: fix timeout (timed, selector) unsubscribe bug
 (#5660)

* 1.x: fix timeout(time, [fallback]) unsubscribe bug

* Fix timeout(selector) variant.
---
 src/main/java/rx/Observable.java              |   6 +-
 ...nSubscribeTimeoutSelectorWithFallback.java | 247 ++++++++++++++++++
 .../OnSubscribeTimeoutTimedWithFallback.java  | 227 ++++++++++++++++
 .../internal/operators/OperatorTimeout.java   |  58 ----
 .../operators/OperatorTimeoutBase.java        | 206 ---------------
 .../OperatorTimeoutWithSelector.java          | 111 --------
 .../operators/OperatorTimeoutTests.java       |  78 +++++-
 .../OperatorTimeoutWithSelectorTest.java      | 178 ++++++++++++-
 8 files changed, 726 insertions(+), 385 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeTimeoutSelectorWithFallback.java
 create mode 100644 src/main/java/rx/internal/operators/OnSubscribeTimeoutTimedWithFallback.java
 delete mode 100644 src/main/java/rx/internal/operators/OperatorTimeout.java
 delete mode 100644 src/main/java/rx/internal/operators/OperatorTimeoutBase.java
 delete mode 100644 src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 6c4b599bb6..4b3d7802b4 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -11284,11 +11284,13 @@ public final <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTi
      *             if {@code timeoutSelector} is null
      * @see <a href="http://reactivex.io/documentation/operators/timeout.html">ReactiveX operators documentation: Timeout</a>
      */
+    @SuppressWarnings("unchecked")
     public final <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTimeoutSelector, Func1<? super T, ? extends Observable<V>> timeoutSelector, Observable<? extends T> other) {
         if (timeoutSelector == null) {
             throw new NullPointerException("timeoutSelector is null");
         }
-        return lift(new OperatorTimeoutWithSelector<T, U, V>(firstTimeoutSelector, timeoutSelector, other));
+        return unsafeCreate(new OnSubscribeTimeoutSelectorWithFallback<T, U, V>(this,
+                firstTimeoutSelector != null ? defer((Func0<Observable<U>>)firstTimeoutSelector) : null, timeoutSelector, other));
     }
 
     /**
@@ -11443,7 +11445,7 @@ public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<?
      * @see <a href="http://reactivex.io/documentation/operators/timeout.html">ReactiveX operators documentation: Timeout</a>
      */
     public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<? extends T> other, Scheduler scheduler) {
-        return lift(new OperatorTimeout<T>(timeout, timeUnit, other, scheduler));
+        return unsafeCreate(new OnSubscribeTimeoutTimedWithFallback<T>(this, timeout, timeUnit, scheduler, other));
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/OnSubscribeTimeoutSelectorWithFallback.java b/src/main/java/rx/internal/operators/OnSubscribeTimeoutSelectorWithFallback.java
new file mode 100644
index 0000000000..75d75777c8
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeTimeoutSelectorWithFallback.java
@@ -0,0 +1,247 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicLong;
+
+import rx.*;
+import rx.exceptions.Exceptions;
+import rx.functions.Func1;
+import rx.internal.operators.OnSubscribeTimeoutTimedWithFallback.FallbackSubscriber;
+import rx.internal.producers.ProducerArbiter;
+import rx.internal.subscriptions.SequentialSubscription;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Switches to the fallback Observable if: the first upstream item doesn't arrive before
+ * the first timeout Observable signals an item or completes; or the Observable generated from
+ * the previous upstream item signals its item or completes before the upstream signals the next item
+ * of its own.
+ *
+ * @param <T> the input and output value type
+ * @param <U> the value type of the first timeout Observable
+ * @param <V> the value type of the item-based timeout Observable
+ *
+ * @since 1.3.3
+ */
+public final class OnSubscribeTimeoutSelectorWithFallback<T, U, V> implements Observable.OnSubscribe<T> {
+
+    final Observable<T> source;
+
+    final Observable<U> firstTimeoutIndicator;
+
+    final Func1<? super T, ? extends Observable<V>> itemTimeoutIndicator;
+
+    final Observable<? extends T> fallback;
+
+    public OnSubscribeTimeoutSelectorWithFallback(Observable<T> source,
+            Observable<U> firstTimeoutIndicator,
+            Func1<? super T, ? extends Observable<V>> itemTimeoutIndicator,
+            Observable<? extends T> fallback) {
+        this.source = source;
+        this.firstTimeoutIndicator = firstTimeoutIndicator;
+        this.itemTimeoutIndicator = itemTimeoutIndicator;
+        this.fallback = fallback;
+    }
+
+    @Override
+    public void call(Subscriber<? super T> t) {
+        TimeoutMainSubscriber<T> parent = new TimeoutMainSubscriber<T>(t, itemTimeoutIndicator, fallback);
+        t.add(parent.upstream);
+        t.setProducer(parent.arbiter);
+        parent.startFirst(firstTimeoutIndicator);
+        source.subscribe(parent);
+    }
+
+    static final class TimeoutMainSubscriber<T> extends Subscriber<T> {
+
+        final Subscriber<? super T> actual;
+
+        final Func1<? super T, ? extends Observable<?>> itemTimeoutIndicator;
+
+        final Observable<? extends T> fallback;
+
+        final ProducerArbiter arbiter;
+
+        final AtomicLong index;
+
+        final SequentialSubscription task;
+
+        final SequentialSubscription upstream;
+
+        long consumed;
+
+        TimeoutMainSubscriber(Subscriber<? super T> actual,
+                Func1<? super T, ? extends Observable<?>> itemTimeoutIndicator,
+                Observable<? extends T> fallback) {
+            this.actual = actual;
+            this.itemTimeoutIndicator = itemTimeoutIndicator;
+            this.fallback = fallback;
+            this.arbiter = new ProducerArbiter();
+            this.index = new AtomicLong();
+            this.task = new SequentialSubscription();
+            this.upstream = new SequentialSubscription(this);
+            this.add(task);
+        }
+
+
+        @Override
+        public void onNext(T t) {
+            long idx = index.get();
+            if (idx == Long.MAX_VALUE || !index.compareAndSet(idx, idx + 1)) {
+                return;
+            }
+
+            Subscription s = task.get();
+            if (s != null) {
+                s.unsubscribe();
+            }
+
+            actual.onNext(t);
+
+            consumed++;
+
+            Observable<?> timeoutObservable;
+
+            try {
+                timeoutObservable = itemTimeoutIndicator.call(t);
+                if (timeoutObservable == null) {
+                    throw new NullPointerException("The itemTimeoutIndicator returned a null Observable");
+                }
+            } catch (Throwable ex) {
+                Exceptions.throwIfFatal(ex);
+                unsubscribe();
+                index.getAndSet(Long.MAX_VALUE);
+                actual.onError(ex);
+                return;
+            }
+
+            TimeoutConsumer tc = new TimeoutConsumer(idx + 1);
+            if (task.replace(tc)) {
+                timeoutObservable.subscribe(tc);
+            }
+
+        }
+
+        void startFirst(Observable<?> firstTimeoutIndicator) {
+            if (firstTimeoutIndicator != null) {
+                TimeoutConsumer tc = new TimeoutConsumer(0L);
+                if (task.replace(tc)) {
+                    firstTimeoutIndicator.subscribe(tc);
+                }
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            if (index.getAndSet(Long.MAX_VALUE) != Long.MAX_VALUE) {
+                task.unsubscribe();
+
+                actual.onError(e);
+            } else {
+                RxJavaHooks.onError(e);
+            }
+        }
+
+        @Override
+        public void onCompleted() {
+            if (index.getAndSet(Long.MAX_VALUE) != Long.MAX_VALUE) {
+                task.unsubscribe();
+
+                actual.onCompleted();
+            }
+        }
+
+        @Override
+        public void setProducer(Producer p) {
+            arbiter.setProducer(p);
+        }
+
+        void onTimeout(long idx) {
+            if (!index.compareAndSet(idx, Long.MAX_VALUE)) {
+                return;
+            }
+
+            unsubscribe();
+
+            if (fallback == null) {
+                actual.onError(new TimeoutException());
+            } else {
+                long c = consumed;
+                if (c != 0L) {
+                    arbiter.produced(c);
+                }
+
+                FallbackSubscriber<T> fallbackSubscriber = new FallbackSubscriber<T>(actual, arbiter);
+
+                if (upstream.replace(fallbackSubscriber)) {
+                    fallback.subscribe(fallbackSubscriber);
+                }
+            }
+        }
+
+        void onTimeoutError(long idx, Throwable ex) {
+            if (index.compareAndSet(idx, Long.MAX_VALUE)) {
+                unsubscribe();
+
+                actual.onError(ex);
+            } else {
+                RxJavaHooks.onError(ex);
+            }
+
+        }
+
+        final class TimeoutConsumer extends Subscriber<Object> {
+
+            final long idx;
+
+            boolean done;
+
+            TimeoutConsumer(long idx) {
+                this.idx = idx;
+            }
+
+            @Override
+            public void onNext(Object t) {
+                if (!done) {
+                    done = true;
+                    unsubscribe();
+                    onTimeout(idx);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                if (!done) {
+                    done = true;
+                    onTimeoutError(idx, e);
+                } else {
+                    RxJavaHooks.onError(e);
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                if (!done) {
+                    done = true;
+                    onTimeout(idx);
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OnSubscribeTimeoutTimedWithFallback.java b/src/main/java/rx/internal/operators/OnSubscribeTimeoutTimedWithFallback.java
new file mode 100644
index 0000000000..e70c57d667
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OnSubscribeTimeoutTimedWithFallback.java
@@ -0,0 +1,227 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ *
+ * 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 rx.internal.operators;
+
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicLong;
+
+import rx.*;
+import rx.Scheduler.Worker;
+import rx.functions.Action0;
+import rx.internal.producers.ProducerArbiter;
+import rx.internal.subscriptions.SequentialSubscription;
+import rx.plugins.RxJavaHooks;
+
+/**
+ * Switches to consuming a fallback Observable if the main source doesn't signal an onNext event
+ * within the given time frame after subscription or the previous onNext event.
+ *
+ * @param <T> the value type
+ * @since 1.3.3
+ */
+public final class OnSubscribeTimeoutTimedWithFallback<T> implements Observable.OnSubscribe<T> {
+
+    final Observable<T> source;
+
+    final long timeout;
+
+    final TimeUnit unit;
+
+    final Scheduler scheduler;
+
+    final Observable<? extends T> fallback;
+
+    public OnSubscribeTimeoutTimedWithFallback(Observable<T> source, long timeout,
+            TimeUnit unit, Scheduler scheduler,
+            Observable<? extends T> fallback) {
+        this.source = source;
+        this.timeout = timeout;
+        this.unit = unit;
+        this.scheduler = scheduler;
+        this.fallback = fallback;
+    }
+
+    @Override
+    public void call(Subscriber<? super T> t) {
+        TimeoutMainSubscriber<T> parent = new TimeoutMainSubscriber<T>(t, timeout, unit, scheduler.createWorker(), fallback);
+        t.add(parent.upstream);
+        t.setProducer(parent.arbiter);
+        parent.startTimeout(0L);
+        source.subscribe(parent);
+    }
+
+    static final class TimeoutMainSubscriber<T> extends Subscriber<T> {
+
+        final Subscriber<? super T> actual;
+
+        final long timeout;
+
+        final TimeUnit unit;
+
+        final Worker worker;
+
+        final Observable<? extends T> fallback;
+
+        final ProducerArbiter arbiter;
+
+        final AtomicLong index;
+
+        final SequentialSubscription task;
+
+        final SequentialSubscription upstream;
+
+        long consumed;
+
+        TimeoutMainSubscriber(Subscriber<? super T> actual, long timeout,
+                TimeUnit unit, Worker worker,
+                Observable<? extends T> fallback) {
+            this.actual = actual;
+            this.timeout = timeout;
+            this.unit = unit;
+            this.worker = worker;
+            this.fallback = fallback;
+            this.arbiter = new ProducerArbiter();
+            this.index = new AtomicLong();
+            this.task = new SequentialSubscription();
+            this.upstream = new SequentialSubscription(this);
+            this.add(worker);
+            this.add(task);
+        }
+
+
+        @Override
+        public void onNext(T t) {
+            long idx = index.get();
+            if (idx == Long.MAX_VALUE || !index.compareAndSet(idx, idx + 1)) {
+                return;
+            }
+
+            Subscription s = task.get();
+            if (s != null) {
+                s.unsubscribe();
+            }
+
+            consumed++;
+
+            actual.onNext(t);
+
+            startTimeout(idx + 1);
+        }
+
+        void startTimeout(long nextIdx) {
+            task.replace(worker.schedule(new TimeoutTask(nextIdx), timeout, unit));
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            if (index.getAndSet(Long.MAX_VALUE) != Long.MAX_VALUE) {
+                task.unsubscribe();
+
+                actual.onError(e);
+
+                worker.unsubscribe();
+            } else {
+                RxJavaHooks.onError(e);
+            }
+        }
+
+        @Override
+        public void onCompleted() {
+            if (index.getAndSet(Long.MAX_VALUE) != Long.MAX_VALUE) {
+                task.unsubscribe();
+
+                actual.onCompleted();
+
+                worker.unsubscribe();
+            }
+        }
+
+        @Override
+        public void setProducer(Producer p) {
+            arbiter.setProducer(p);
+        }
+
+        void onTimeout(long idx) {
+            if (!index.compareAndSet(idx, Long.MAX_VALUE)) {
+                return;
+            }
+
+            unsubscribe();
+
+            if (fallback == null) {
+                actual.onError(new TimeoutException());
+            } else {
+                long c = consumed;
+                if (c != 0L) {
+                    arbiter.produced(c);
+                }
+
+                FallbackSubscriber<T> fallbackSubscriber = new FallbackSubscriber<T>(actual, arbiter);
+
+                if (upstream.replace(fallbackSubscriber)) {
+                    fallback.subscribe(fallbackSubscriber);
+                }
+            }
+        }
+
+        final class TimeoutTask implements Action0 {
+
+            final long idx;
+
+            TimeoutTask(long idx) {
+                this.idx = idx;
+            }
+
+            @Override
+            public void call() {
+                onTimeout(idx);
+            }
+        }
+    }
+
+    static final class FallbackSubscriber<T> extends Subscriber<T> {
+
+        final Subscriber<? super T> actual;
+
+        final ProducerArbiter arbiter;
+
+        FallbackSubscriber(Subscriber<? super T> actual, ProducerArbiter arbiter) {
+            this.actual = actual;
+            this.arbiter = arbiter;
+        }
+
+        @Override
+        public void onNext(T t) {
+            actual.onNext(t);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            actual.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            actual.onCompleted();
+        }
+
+        @Override
+        public void setProducer(Producer p) {
+            arbiter.setProducer(p);
+        }
+    }
+}
diff --git a/src/main/java/rx/internal/operators/OperatorTimeout.java b/src/main/java/rx/internal/operators/OperatorTimeout.java
deleted file mode 100644
index 3c74663e80..0000000000
--- a/src/main/java/rx/internal/operators/OperatorTimeout.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- *
- * 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 rx.internal.operators;
-
-import java.util.concurrent.TimeUnit;
-
-import rx.*;
-import rx.functions.Action0;
-
-/**
- * Applies a timeout policy for each element in the observable sequence, using
- * the specified scheduler to run timeout timers. If the next element isn't
- * received within the specified timeout duration starting from its predecessor,
- * the other observable sequence is used to produce future messages from that
- * point on.
- * @param <T> the value type
- */
-public final class OperatorTimeout<T> extends OperatorTimeoutBase<T> {
-
-    public OperatorTimeout(final long timeout, final TimeUnit timeUnit, Observable<? extends T> other, Scheduler scheduler) {
-        super(new FirstTimeoutStub<T>() {
-
-            @Override
-            public Subscription call(final TimeoutSubscriber<T> timeoutSubscriber, final Long seqId, Scheduler.Worker inner) {
-                return inner.schedule(new Action0() {
-                    @Override
-                    public void call() {
-                        timeoutSubscriber.onTimeout(seqId);
-                    }
-                }, timeout, timeUnit);
-            }
-        }, new TimeoutStub<T>() {
-
-            @Override
-            public Subscription call(final TimeoutSubscriber<T> timeoutSubscriber, final Long seqId, T value, Scheduler.Worker inner) {
-                return inner.schedule(new Action0() {
-                    @Override
-                    public void call() {
-                        timeoutSubscriber.onTimeout(seqId);
-                    }
-                }, timeout, timeUnit);
-            }
-        }, other, scheduler);
-    }
-}
diff --git a/src/main/java/rx/internal/operators/OperatorTimeoutBase.java b/src/main/java/rx/internal/operators/OperatorTimeoutBase.java
deleted file mode 100644
index 435a60e503..0000000000
--- a/src/main/java/rx/internal/operators/OperatorTimeoutBase.java
+++ /dev/null
@@ -1,206 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- *
- * 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 rx.internal.operators;
-
-import java.util.concurrent.TimeoutException;
-
-import rx.*;
-import rx.Observable.Operator;
-import rx.functions.*;
-import rx.internal.producers.ProducerArbiter;
-import rx.observers.SerializedSubscriber;
-import rx.subscriptions.SerialSubscription;
-
-class OperatorTimeoutBase<T> implements Operator<T, T> {
-    final FirstTimeoutStub<T> firstTimeoutStub;
-    final TimeoutStub<T> timeoutStub;
-    final Observable<? extends T> other;
-    final Scheduler scheduler;
-
-    /**
-     * Set up the timeout action on the first value.
-     *
-     * @param <T>
-     */
-    /* package-private */interface FirstTimeoutStub<T> extends
-            Func3<TimeoutSubscriber<T>, Long, Scheduler.Worker, Subscription> {
-    }
-
-    /**
-     * Set up the timeout action based on every value
-     *
-     * @param <T>
-     */
-    /* package-private */interface TimeoutStub<T> extends
-            Func4<TimeoutSubscriber<T>, Long, T, Scheduler.Worker, Subscription> {
-    }
-
-    /* package-private */OperatorTimeoutBase(FirstTimeoutStub<T> firstTimeoutStub, TimeoutStub<T> timeoutStub, Observable<? extends T> other, Scheduler scheduler) {
-        this.firstTimeoutStub = firstTimeoutStub;
-        this.timeoutStub = timeoutStub;
-        this.other = other;
-        this.scheduler = scheduler;
-    }
-
-    @Override
-    public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
-        Scheduler.Worker inner = scheduler.createWorker();
-        subscriber.add(inner);
-        // Use SynchronizedSubscriber for safe memory access
-        // as the subscriber will be accessed in the current thread or the
-        // scheduler or other Observables.
-        final SerializedSubscriber<T> synchronizedSubscriber = new SerializedSubscriber<T>(subscriber);
-
-        final SerialSubscription serial = new SerialSubscription();
-        synchronizedSubscriber.add(serial);
-
-        TimeoutSubscriber<T> timeoutSubscriber = new TimeoutSubscriber<T>(synchronizedSubscriber, timeoutStub, serial, other, inner);
-
-        synchronizedSubscriber.add(timeoutSubscriber);
-        synchronizedSubscriber.setProducer(timeoutSubscriber.arbiter);
-
-        serial.set(firstTimeoutStub.call(timeoutSubscriber, 0L, inner));
-
-        return timeoutSubscriber;
-    }
-
-    /* package-private */static final class TimeoutSubscriber<T> extends
-            Subscriber<T> {
-
-        final SerialSubscription serial;
-
-        final SerializedSubscriber<T> serializedSubscriber;
-
-        final TimeoutStub<T> timeoutStub;
-
-        final Observable<? extends T> other;
-
-        final Scheduler.Worker inner;
-
-        final ProducerArbiter arbiter;
-
-        /** Guarded by this. */
-        boolean terminated;
-        /** Guarded by this. */
-        long actual;
-
-        TimeoutSubscriber(
-                SerializedSubscriber<T> serializedSubscriber,
-                TimeoutStub<T> timeoutStub, SerialSubscription serial,
-                Observable<? extends T> other,
-                Scheduler.Worker inner) {
-            this.serializedSubscriber = serializedSubscriber;
-            this.timeoutStub = timeoutStub;
-            this.serial = serial;
-            this.other = other;
-            this.inner = inner;
-            this.arbiter = new ProducerArbiter();
-        }
-
-        @Override
-        public void setProducer(Producer p) {
-            arbiter.setProducer(p);
-        }
-
-        @Override
-        public void onNext(T value) {
-            boolean onNextWins = false;
-            long a;
-            synchronized (this) {
-                if (!terminated) {
-                    a = ++actual;
-                    onNextWins = true;
-                } else {
-                    a = actual;
-                }
-            }
-            if (onNextWins) {
-                serializedSubscriber.onNext(value);
-                serial.set(timeoutStub.call(this, a, value, inner));
-            }
-        }
-
-        @Override
-        public void onError(Throwable error) {
-            boolean onErrorWins = false;
-            synchronized (this) {
-                if (!terminated) {
-                    terminated = true;
-                    onErrorWins = true;
-                }
-            }
-            if (onErrorWins) {
-                serial.unsubscribe();
-                serializedSubscriber.onError(error);
-            }
-        }
-
-        @Override
-        public void onCompleted() {
-            boolean onCompletedWins = false;
-            synchronized (this) {
-                if (!terminated) {
-                    terminated = true;
-                    onCompletedWins = true;
-                }
-            }
-            if (onCompletedWins) {
-                serial.unsubscribe();
-                serializedSubscriber.onCompleted();
-            }
-        }
-
-        public void onTimeout(long seqId) {
-            long expected = seqId;
-            boolean timeoutWins = false;
-            synchronized (this) {
-                if (expected == actual && !terminated) {
-                    terminated = true;
-                    timeoutWins = true;
-                }
-            }
-            if (timeoutWins) {
-                if (other == null) {
-                    serializedSubscriber.onError(new TimeoutException());
-                } else {
-                    Subscriber<T> second = new Subscriber<T>() {
-                        @Override
-                        public void onNext(T t) {
-                            serializedSubscriber.onNext(t);
-                        }
-
-                        @Override
-                        public void onError(Throwable e) {
-                            serializedSubscriber.onError(e);
-                        }
-
-                        @Override
-                        public void onCompleted() {
-                            serializedSubscriber.onCompleted();
-                        }
-
-                        @Override
-                        public void setProducer(Producer p) {
-                            arbiter.setProducer(p);
-                        }
-                    };
-                    other.unsafeSubscribe(second);
-                    serial.set(second);
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java b/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
deleted file mode 100644
index 16034dba6c..0000000000
--- a/src/main/java/rx/internal/operators/OperatorTimeoutWithSelector.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/**
- * Copyright 2014 Netflix, Inc.
- *
- * 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 rx.internal.operators;
-
-import rx.*;
-import rx.exceptions.Exceptions;
-import rx.functions.*;
-import rx.schedulers.Schedulers;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Returns an Observable that mirrors the source Observable. If either the first
- * item emitted by the source Observable or any subsequent item don't arrive
- * within time windows defined by provided Observables, switch to the
- * <code>other</code> Observable if provided, or emit a TimeoutException .
- * @param <T> the value type of the main Observable
- * @param <U> the value type of the first timeout Observable
- * @param <V> the value type of the subsequent timeout Observable
- */
-public class OperatorTimeoutWithSelector<T, U, V> extends
-        OperatorTimeoutBase<T> {
-
-    public OperatorTimeoutWithSelector(
-            final Func0<? extends Observable<U>> firstTimeoutSelector,
-            final Func1<? super T, ? extends Observable<V>> timeoutSelector,
-            Observable<? extends T> other) {
-        super(new FirstTimeoutStub<T>() {
-
-            @Override
-            public Subscription call(
-                    final TimeoutSubscriber<T> timeoutSubscriber,
-                    final Long seqId, Scheduler.Worker inner) {
-                if (firstTimeoutSelector != null) {
-                    Observable<U> o;
-                    try {
-                        o = firstTimeoutSelector.call();
-                    } catch (Throwable t) {
-                        Exceptions.throwOrReport(t, timeoutSubscriber);
-                        return Subscriptions.unsubscribed();
-                    }
-                    return o.unsafeSubscribe(new Subscriber<U>() {
-
-                        @Override
-                        public void onCompleted() {
-                            timeoutSubscriber.onTimeout(seqId);
-                        }
-
-                        @Override
-                        public void onError(Throwable e) {
-                            timeoutSubscriber.onError(e);
-                        }
-
-                        @Override
-                        public void onNext(U t) {
-                            timeoutSubscriber.onTimeout(seqId);
-                        }
-
-                    });
-                } else {
-                    return Subscriptions.unsubscribed();
-                }
-            }
-        }, new TimeoutStub<T>() {
-
-            @Override
-            public Subscription call(
-                    final TimeoutSubscriber<T> timeoutSubscriber,
-                    final Long seqId, T value, Scheduler.Worker inner) {
-                Observable<V> o;
-                try {
-                    o = timeoutSelector.call(value);
-                } catch (Throwable t) {
-                    Exceptions.throwOrReport(t, timeoutSubscriber);
-                    return Subscriptions.unsubscribed();
-                }
-                return o.unsafeSubscribe(new Subscriber<V>() {
-
-                    @Override
-                    public void onCompleted() {
-                        timeoutSubscriber.onTimeout(seqId);
-                    }
-
-                    @Override
-                    public void onError(Throwable e) {
-                        timeoutSubscriber.onError(e);
-                    }
-
-                    @Override
-                    public void onNext(V t) {
-                        timeoutSubscriber.onTimeout(seqId);
-                    }
-
-                });
-            }
-        }, other, Schedulers.immediate());
-    }
-
-}
diff --git a/src/test/java/rx/internal/operators/OperatorTimeoutTests.java b/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
index fba5b1d6c5..6be7706d0f 100644
--- a/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
+++ b/src/test/java/rx/internal/operators/OperatorTimeoutTests.java
@@ -15,21 +15,26 @@
  */
 package rx.internal.operators;
 
+import static org.junit.Assert.assertEquals;
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
+import java.util.*;
 import java.util.concurrent.*;
 
 import org.junit.*;
 import org.mockito.*;
 
 import rx.*;
+import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.functions.Func1;
-import rx.observers.TestSubscriber;
+import rx.Observer;
+import rx.exceptions.TestException;
+import rx.functions.*;
+import rx.observers.*;
 import rx.schedulers.TestScheduler;
-import rx.subjects.PublishSubject;
+import rx.subjects.*;
 
 public class OperatorTimeoutTests {
     private PublishSubject<String> underlyingSubject;
@@ -427,4 +432,71 @@ public void withDefaultSchedulerAndOther() {
         ts.assertNoErrors();
         ts.assertCompleted();
     }
+
+    @Test
+    public void disconnectOnTimeout() {
+        final List<String> list = Collections.synchronizedList(new ArrayList<String>());
+
+        TestScheduler sch = new TestScheduler();
+
+        Subject<Long, Long> subject = PublishSubject.create();
+        Observable<Long> initialObservable = subject.share()
+        .map(new Func1<Long, Long>() {
+            @Override
+            public Long call(Long value) {
+                list.add("Received value " + value);
+                return value;
+            }
+        });
+
+        Observable<Long> timeoutObservable = initialObservable
+        .map(new Func1<Long, Long>() {
+            @Override
+            public Long call(Long value) {
+               list.add("Timeout received value " + value);
+               return value;
+            }
+        });
+
+        TestSubscriber<Long> subscriber = new TestSubscriber<Long>();
+        initialObservable
+        .doOnUnsubscribe(new Action0() {
+            @Override
+            public void call() {
+                list.add("Unsubscribed");
+            }
+        })
+        .timeout(1, TimeUnit.SECONDS, timeoutObservable, sch).subscribe(subscriber);
+
+        subject.onNext(5L);
+
+        sch.advanceTimeBy(2, TimeUnit.SECONDS);
+
+        subject.onNext(10L);
+        subject.onCompleted();
+
+        subscriber.awaitTerminalEvent();
+        subscriber.assertNoErrors();
+        subscriber.assertValues(5L, 10L);
+
+        assertEquals(Arrays.asList(
+                "Received value 5",
+                "Unsubscribed",
+                "Received value 10",
+                "Timeout received value 10"
+        ), list);
+    }
+
+    @Test
+    public void fallbackIsError() {
+        TestScheduler sch = new TestScheduler();
+
+        AssertableSubscriber<Object> as = Observable.never()
+                .timeout(1, TimeUnit.SECONDS, Observable.error(new TestException()), sch)
+        .test();
+
+        sch.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        as.assertFailure(TestException.class);
+    }
 }
diff --git a/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java b/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
index 50ce9e5865..628d1eca55 100644
--- a/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTimeoutWithSelectorTest.java
@@ -19,7 +19,8 @@
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
-import java.util.Arrays;
+import java.io.IOException;
+import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
@@ -28,13 +29,15 @@
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
-import rx.*;
+import rx.Observable;
 import rx.Observable.OnSubscribe;
+import rx.Observer;
+import rx.Subscriber;
 import rx.exceptions.TestException;
 import rx.functions.*;
-import rx.observers.TestSubscriber;
-import rx.schedulers.Schedulers;
-import rx.subjects.PublishSubject;
+import rx.observers.*;
+import rx.schedulers.*;
+import rx.subjects.*;
 
 public class OperatorTimeoutWithSelectorTest {
     @Test(timeout = 2000)
@@ -439,4 +442,169 @@ public Observable<Object> call() {
             assertEquals("timeoutSelector is null", ex.getMessage());
         }
     }
+
+    @Test
+    public void disconnectOnTimeout() {
+        final List<String> list = Collections.synchronizedList(new ArrayList<String>());
+
+        final TestScheduler sch = new TestScheduler();
+
+        Subject<Long, Long> subject = PublishSubject.create();
+        Observable<Long> initialObservable = subject.share()
+        .map(new Func1<Long, Long>() {
+            @Override
+            public Long call(Long value) {
+                list.add("Received value " + value);
+                return value;
+            }
+        });
+
+        Observable<Long> timeoutObservable = initialObservable
+        .map(new Func1<Long, Long>() {
+            @Override
+            public Long call(Long value) {
+               list.add("Timeout received value " + value);
+               return value;
+            }
+        });
+
+        TestSubscriber<Long> subscriber = new TestSubscriber<Long>();
+        initialObservable
+        .doOnUnsubscribe(new Action0() {
+            @Override
+            public void call() {
+                list.add("Unsubscribed");
+            }
+        })
+        .timeout(
+                new Func0<Observable<Long>>() {
+                    @Override
+                    public Observable<Long> call() {
+                        return Observable.timer(1, TimeUnit.SECONDS, sch);
+                    }
+                },
+                new Func1<Long, Observable<Long>>() {
+                    @Override
+                    public Observable<Long> call(Long v) {
+                        return Observable.timer(1, TimeUnit.SECONDS, sch);
+                    }
+                },
+                timeoutObservable).subscribe(subscriber);
+
+        subject.onNext(5L);
+
+        sch.advanceTimeBy(2, TimeUnit.SECONDS);
+
+        subject.onNext(10L);
+        subject.onCompleted();
+
+        subscriber.awaitTerminalEvent();
+        subscriber.assertNoErrors();
+        subscriber.assertValues(5L, 10L);
+
+        assertEquals(Arrays.asList(
+                "Received value 5",
+                "Unsubscribed",
+                "Received value 10",
+                "Timeout received value 10"
+        ), list);
+    }
+
+    @Test
+    public void fallbackIsError() {
+        final TestScheduler sch = new TestScheduler();
+
+        AssertableSubscriber<Object> as = Observable.never()
+                .timeout(new Func0<Observable<Long>>() {
+                    @Override
+                    public Observable<Long> call() {
+                        return Observable.timer(1, TimeUnit.SECONDS, sch);
+                    }
+                },
+                new Func1<Object, Observable<Long>>() {
+                    @Override
+                    public Observable<Long> call(Object v) {
+                        return Observable.timer(1, TimeUnit.SECONDS, sch);
+                    }
+                }, Observable.error(new TestException()))
+        .test();
+
+        sch.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        as.assertFailure(TestException.class);
+    }
+
+    @Test
+    public void mainErrors() {
+        final TestScheduler sch = new TestScheduler();
+
+        AssertableSubscriber<Object> as = Observable.error(new IOException())
+                .timeout(new Func0<Observable<Long>>() {
+                    @Override
+                    public Observable<Long> call() {
+                        return Observable.timer(1, TimeUnit.SECONDS, sch);
+                    }
+                },
+                new Func1<Object, Observable<Long>>() {
+                    @Override
+                    public Observable<Long> call(Object v) {
+                        return Observable.timer(1, TimeUnit.SECONDS, sch);
+                    }
+                }, Observable.error(new TestException()))
+        .test();
+
+        as.assertFailure(IOException.class);
+
+        sch.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        as.assertFailure(IOException.class);
+    }
+
+    @Test
+    public void timeoutCompletesWithFallback() {
+        final TestScheduler sch = new TestScheduler();
+
+        AssertableSubscriber<Object> as = Observable.never()
+                .timeout(new Func0<Observable<Long>>() {
+                    @Override
+                    public Observable<Long> call() {
+                        return Observable.timer(1, TimeUnit.SECONDS, sch).ignoreElements();
+                    }
+                },
+                new Func1<Object, Observable<Long>>() {
+                    @Override
+                    public Observable<Long> call(Object v) {
+                        return Observable.timer(1, TimeUnit.SECONDS, sch);
+                    }
+                }, Observable.just(1))
+        .test();
+
+        sch.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        as.assertResult(1);
+    }
+
+    @Test
+    public void nullItemTimeout() {
+        final TestScheduler sch = new TestScheduler();
+
+        AssertableSubscriber<Integer> as = Observable.just(1).concatWith(Observable.<Integer>never())
+                .timeout(new Func0<Observable<Long>>() {
+                    @Override
+                    public Observable<Long> call() {
+                        return Observable.timer(1, TimeUnit.SECONDS, sch).ignoreElements();
+                    }
+                },
+                new Func1<Object, Observable<Long>>() {
+                    @Override
+                    public Observable<Long> call(Object v) {
+                        return null;
+                    }
+                }, Observable.just(1))
+        .test();
+
+        sch.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        as.assertFailureAndMessage(NullPointerException.class, "The itemTimeoutIndicator returned a null Observable", 1);
+    }
 }

From 396b6104e419b80002c45faf76ac38f00d2ff64a Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 19 Oct 2017 10:54:04 +0200
Subject: [PATCH 248/263] Release 1.3.3

---
 CHANGES.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 3a834830b7..b8ac66c635 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,11 @@
 # RxJava Releases #
 
+### Version 1.3.3 - October 19, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.3%7C))
+
+#### Bugfixes
+
+- [Pull 5660](https://github.com/ReactiveX/RxJava/pull/5660): Fix `timeout` (timed, selector) unsubscribe bug.
+
 ### Version 1.3.2 - September 15, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.2%7C))
 
 #### Bugfixes

From 5b2394c9ee91f298661fff5e043744c84b425808 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 31 Oct 2017 19:37:55 +0100
Subject: [PATCH 249/263] 1.x: fix Completable.concat to use replace (don't
 dispose old) (#5696)

* 1.x: fix Completable.concat to use replace (don't dispose old)

* Remove original issue comments
---
 .../CompletableOnSubscribeConcatArray.java    |  8 +-
 .../CompletableOnSubscribeConcatIterable.java |  9 ++-
 .../operators/CompletableConcatTest.java      | 79 ++++++++++++++++++-
 3 files changed, 87 insertions(+), 9 deletions(-)

diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
index f291f0f649..cbac07ded5 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatArray.java
@@ -20,7 +20,7 @@
 
 import rx.*;
 import rx.Completable.OnSubscribe;
-import rx.subscriptions.SerialSubscription;
+import rx.internal.subscriptions.SequentialSubscription;
 
 public final class CompletableOnSubscribeConcatArray implements OnSubscribe {
     final Completable[] sources;
@@ -45,17 +45,17 @@ static final class ConcatInnerSubscriber extends AtomicInteger implements Comple
 
         int index;
 
-        final SerialSubscription sd;
+        final SequentialSubscription sd;
 
         public ConcatInnerSubscriber(CompletableSubscriber actual, Completable[] sources) {
             this.actual = actual;
             this.sources = sources;
-            this.sd = new SerialSubscription();
+            this.sd = new SequentialSubscription();
         }
 
         @Override
         public void onSubscribe(Subscription d) {
-            sd.set(d);
+            sd.replace(d);
         }
 
         @Override
diff --git a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
index e5a3e95fc7..7506286906 100644
--- a/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
+++ b/src/main/java/rx/internal/operators/CompletableOnSubscribeConcatIterable.java
@@ -21,7 +21,8 @@
 
 import rx.*;
 import rx.Completable.OnSubscribe;
-import rx.subscriptions.*;
+import rx.internal.subscriptions.SequentialSubscription;
+import rx.subscriptions.Subscriptions;
 
 public final class CompletableOnSubscribeConcatIterable implements OnSubscribe {
     final Iterable<? extends Completable> sources;
@@ -61,17 +62,17 @@ static final class ConcatInnerSubscriber extends AtomicInteger implements Comple
         final CompletableSubscriber actual;
         final Iterator<? extends Completable> sources;
 
-        final SerialSubscription sd;
+        final SequentialSubscription sd;
 
         public ConcatInnerSubscriber(CompletableSubscriber actual, Iterator<? extends Completable> sources) {
             this.actual = actual;
             this.sources = sources;
-            this.sd = new SerialSubscription();
+            this.sd = new SequentialSubscription();
         }
 
         @Override
         public void onSubscribe(Subscription d) {
-            sd.set(d);
+            sd.replace(d);
         }
 
         @Override
diff --git a/src/test/java/rx/internal/operators/CompletableConcatTest.java b/src/test/java/rx/internal/operators/CompletableConcatTest.java
index d05b11fc45..f55898193c 100644
--- a/src/test/java/rx/internal/operators/CompletableConcatTest.java
+++ b/src/test/java/rx/internal/operators/CompletableConcatTest.java
@@ -16,7 +16,11 @@
 
 package rx.internal.operators;
 
-import java.util.concurrent.TimeUnit;
+import static org.junit.Assert.assertFalse;
+
+import java.util.Arrays;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.*;
 
@@ -58,4 +62,77 @@ public void call() {
 
         Assert.assertEquals(5, calls[0]);
     }
+
+    @Test
+    public void andThenNoInterrupt() throws InterruptedException {
+        for (int k = 0; k < 100; k++) {
+            final int count = 10;
+            final CountDownLatch latch = new CountDownLatch(count);
+            final AtomicBoolean interrupted = new AtomicBoolean();
+
+            for (int i = 0; i < count; i++) {
+                Completable.complete()
+                .subscribeOn(Schedulers.io())
+                .observeOn(Schedulers.io())
+                .andThen(Completable.fromAction(new Action0() {
+                    @Override
+                    public void call() {
+                        try {
+                            Thread.sleep(30);
+                        } catch (InterruptedException e) {
+                            System.out.println("Interrupted! " + Thread.currentThread());
+                            interrupted.set(true);
+                        }
+                    }
+                }))
+                .subscribe(new Action0() {
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+                });
+            }
+
+            latch.await();
+            assertFalse("The second Completable was interrupted!", interrupted.get());
+        }
+    }
+
+    @Test
+    public void noInterrupt() throws InterruptedException {
+        for (int k = 0; k < 100; k++) {
+            final int count = 10;
+            final CountDownLatch latch = new CountDownLatch(count);
+            final AtomicBoolean interrupted = new AtomicBoolean();
+
+            for (int i = 0; i < count; i++) {
+                Completable c0 = Completable.fromAction(new Action0() {
+                    @Override
+                    public void call() {
+                        try {
+                            Thread.sleep(30);
+                        } catch (InterruptedException e) {
+                            System.out.println("Interrupted! " + Thread.currentThread());
+                            interrupted.set(true);
+                        }
+                    }
+                });
+                Completable.concat(Arrays.asList(Completable.complete()
+                    .subscribeOn(Schedulers.io())
+                    .observeOn(Schedulers.io()),
+                    c0)
+                )
+                .subscribe(new Action0() {
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+                });
+            }
+
+            latch.await();
+            assertFalse("The second Completable was interrupted!", interrupted.get());
+        }
+    }
+
 }

From 048175a529f4b29b8c9778d3aecd4989fba4e486 Mon Sep 17 00:00:00 2001
From: Sadegh <sadegh.kazemy@gmail.com>
Date: Sat, 11 Nov 2017 17:00:46 +0330
Subject: [PATCH 250/263] 1.x: Add a sentence to documentation of take()
 operator (#5719)

* Add a sentence to documentation of take() operator

* Rephrase java doc for take() method
---
 src/main/java/rx/Observable.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 4b3d7802b4..5d1896008e 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -10536,6 +10536,9 @@ public final Observable<T> take(final int count) {
      * Returns an Observable that emits those items emitted by source Observable before a specified time runs
      * out.
      * <p>
+     * If time runs out before the {@code Observable} completes normally, the {@code onComplete} event will be
+     * signaled on the default {@code computation} {@link Scheduler}.
+     * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/take.t.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>
@@ -10560,6 +10563,9 @@ public final Observable<T> take(long time, TimeUnit unit) {
      * Returns an Observable that emits those items emitted by source Observable before a specified time (on a
      * specified Scheduler) runs out.
      * <p>
+     * If time runs out before the {@code Observable} completes normally, the {@code onComplete} event will be
+     * signaled on the provided {@link Scheduler}.
+     * <p>
      * <img width="640" height="305" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/take.ts.png" alt="">
      * <dl>
      *  <dt><b>Backpressure:</b></dt>

From bd862bc2335fe64190a8503da81c5146b9aadad7 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 16 Nov 2017 09:36:46 +0100
Subject: [PATCH 251/263] 1.x: fix broken backpressure through unsubscribeOn()
 (#5726)

---
 .../operators/OperatorUnsubscribeOn.java      |  4 +++
 .../operators/OperatorUnsubscribeOnTest.java  | 27 +++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java b/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
index 2f72d62d6b..a581009884 100644
--- a/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
+++ b/src/main/java/rx/internal/operators/OperatorUnsubscribeOn.java
@@ -52,6 +52,10 @@ public void onNext(T t) {
                 subscriber.onNext(t);
             }
 
+            @Override
+            public void setProducer(Producer p) {
+                subscriber.setProducer(p);
+            }
         };
 
         subscriber.add(Subscriptions.create(new Action0() {
diff --git a/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java b/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
index fe8d664122..c409a467bf 100644
--- a/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
+++ b/src/test/java/rx/internal/operators/OperatorUnsubscribeOnTest.java
@@ -204,4 +204,31 @@ public Thread getThread() {
         }
 
     }
+
+    @Test
+    public void backpressure() {
+        AssertableSubscriber<Integer> as = Observable.range(1, 10)
+        .unsubscribeOn(Schedulers.trampoline())
+        .test(0);
+
+        as.assertNoValues()
+        .assertNoErrors()
+        .assertNotCompleted();
+
+        as.requestMore(1);
+
+        as.assertValue(1)
+        .assertNoErrors()
+        .assertNotCompleted();
+
+        as.requestMore(3);
+
+        as.assertValues(1, 2, 3, 4)
+        .assertNoErrors()
+        .assertNotCompleted();
+
+        as.requestMore(10);
+
+        as.assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    }
 }
\ No newline at end of file

From 265fb484f504e093da508811c498e6241975950e Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sun, 19 Nov 2017 11:40:40 +0100
Subject: [PATCH 252/263] Release 1.3.4

---
 CHANGES.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index b8ac66c635..41d2e5b164 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,16 @@
 # RxJava Releases #
 
+### Version 1.3.4 - November 19, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.4%7C))
+
+#### Bugfixes
+
+- [Pull 5696](https://github.com/ReactiveX/RxJava/pull/5696): Fix `Completable.concat` to use `replace` and don't dispose the old `Subscription` on switching to the next source.
+- [Pull 5726](https://github.com/ReactiveX/RxJava/pull/5726): Fix broken backpressure through `unsubscribeOn()`.
+
+#### Documentation
+
+- [Pull 5719](https://github.com/ReactiveX/RxJava/pull/5719): Document the timed `take()` operator will signal the `onCompleted` event on the given `Scheduler` when it times out.
+
 ### Version 1.3.3 - October 19, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.3%7C))
 
 #### Bugfixes

From ef329508bc686cd68614da8676bb6b903c82e67a Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 25 Jan 2018 13:39:59 +0100
Subject: [PATCH 253/263] 1.x: Plugin lookup workaround for System.properties
 access restrictions (#5820)

* 1.x: Plugin lookup workaround for System.properties access restrictions

* System.getProperties() can also throw SecurityException
---
 src/main/java/rx/plugins/RxJavaPlugins.java   | 54 +++++++++-----
 .../java/rx/plugins/RxJavaPluginsTest.java    | 72 +++++++++++++++++++
 2 files changed, 109 insertions(+), 17 deletions(-)

diff --git a/src/main/java/rx/plugins/RxJavaPlugins.java b/src/main/java/rx/plugins/RxJavaPlugins.java
index 7a5856d431..cac5b167c6 100644
--- a/src/main/java/rx/plugins/RxJavaPlugins.java
+++ b/src/main/java/rx/plugins/RxJavaPlugins.java
@@ -105,7 +105,7 @@ public void reset() {
     public RxJavaErrorHandler getErrorHandler() {
         if (errorHandler.get() == null) {
             // check for an implementation from System.getProperty first
-            Object impl = getPluginImplementationViaProperty(RxJavaErrorHandler.class, System.getProperties());
+            Object impl = getPluginImplementationViaProperty(RxJavaErrorHandler.class, getSystemPropertiesSafe());
             if (impl == null) {
                 // nothing set via properties so initialize with default
                 errorHandler.compareAndSet(null, DEFAULT_ERROR_HANDLER);
@@ -147,7 +147,7 @@ public void registerErrorHandler(RxJavaErrorHandler impl) {
     public RxJavaObservableExecutionHook getObservableExecutionHook() {
         if (observableExecutionHook.get() == null) {
             // check for an implementation from System.getProperty first
-            Object impl = getPluginImplementationViaProperty(RxJavaObservableExecutionHook.class, System.getProperties());
+            Object impl = getPluginImplementationViaProperty(RxJavaObservableExecutionHook.class, getSystemPropertiesSafe());
             if (impl == null) {
                 // nothing set via properties so initialize with default
                 observableExecutionHook.compareAndSet(null, RxJavaObservableExecutionHookDefault.getInstance());
@@ -189,7 +189,7 @@ public void registerObservableExecutionHook(RxJavaObservableExecutionHook impl)
     public RxJavaSingleExecutionHook getSingleExecutionHook() {
         if (singleExecutionHook.get() == null) {
             // check for an implementation from System.getProperty first
-            Object impl = getPluginImplementationViaProperty(RxJavaSingleExecutionHook.class, System.getProperties());
+            Object impl = getPluginImplementationViaProperty(RxJavaSingleExecutionHook.class, getSystemPropertiesSafe());
             if (impl == null) {
                 // nothing set via properties so initialize with default
                 singleExecutionHook.compareAndSet(null, RxJavaSingleExecutionHookDefault.getInstance());
@@ -232,7 +232,7 @@ public void registerSingleExecutionHook(RxJavaSingleExecutionHook impl) {
     public RxJavaCompletableExecutionHook getCompletableExecutionHook() {
         if (completableExecutionHook.get() == null) {
             // check for an implementation from System.getProperty first
-            Object impl = getPluginImplementationViaProperty(RxJavaCompletableExecutionHook.class, System.getProperties());
+            Object impl = getPluginImplementationViaProperty(RxJavaCompletableExecutionHook.class, getSystemPropertiesSafe());
             if (impl == null) {
                 // nothing set via properties so initialize with default
                 completableExecutionHook.compareAndSet(null, new RxJavaCompletableExecutionHook() { });
@@ -262,6 +262,19 @@ public void registerCompletableExecutionHook(RxJavaCompletableExecutionHook impl
         }
     }
 
+    /**
+     * A security manager may prevent accessing the System properties entirely,
+     * therefore, the SecurityException is turned into an empty properties.
+     * @return the Properties to use for looking up settings
+     */
+    /* test */ static Properties getSystemPropertiesSafe() {
+        try {
+            return System.getProperties();
+        } catch (SecurityException ex) {
+            return new Properties();
+        }
+    }
+
     /* test */ static Object getPluginImplementationViaProperty(Class<?> pluginClass, Properties propsIn) {
         // Make a defensive clone because traversal may fail with ConcurrentModificationException
         // if the properties get changed by something outside RxJava.
@@ -284,25 +297,32 @@ public void registerCompletableExecutionHook(RxJavaCompletableExecutionHook impl
             String classSuffix = ".class";
             String implSuffix = ".impl";
 
-            for (Map.Entry<Object, Object> e : props.entrySet()) {
-                String key = e.getKey().toString();
-                if (key.startsWith(pluginPrefix) && key.endsWith(classSuffix)) {
-                    String value = e.getValue().toString();
+            try {
+                for (Map.Entry<Object, Object> e : props.entrySet()) {
+                    String key = e.getKey().toString();
+                    if (key.startsWith(pluginPrefix) && key.endsWith(classSuffix)) {
+                        String value = e.getValue().toString();
+
+                        if (classSimpleName.equals(value)) {
+                            String index = key.substring(0, key.length() - classSuffix.length()).substring(pluginPrefix.length());
 
-                    if (classSimpleName.equals(value)) {
-                        String index = key.substring(0, key.length() - classSuffix.length()).substring(pluginPrefix.length());
+                            String implKey = pluginPrefix + index + implSuffix;
 
-                        String implKey = pluginPrefix + index + implSuffix;
+                            implementingClass = props.getProperty(implKey);
 
-                        implementingClass = props.getProperty(implKey);
+                            if (implementingClass == null) {
+                                throw new IllegalStateException("Implementing class declaration for " + classSimpleName + " missing: " + implKey);
+                            }
 
-                        if (implementingClass == null) {
-                            throw new IllegalStateException("Implementing class declaration for " + classSimpleName + " missing: " + implKey);
+                            break;
                         }
-
-                        break;
                     }
                 }
+            } catch (SecurityException ex) {
+                // https://github.com/ReactiveX/RxJava/issues/5819
+                // We don't seem to have access to all properties.
+                // At least print the exception to the console.
+                ex.printStackTrace();
             }
         }
 
@@ -339,7 +359,7 @@ public void registerCompletableExecutionHook(RxJavaCompletableExecutionHook impl
     public RxJavaSchedulersHook getSchedulersHook() {
         if (schedulersHook.get() == null) {
             // check for an implementation from System.getProperty first
-            Object impl = getPluginImplementationViaProperty(RxJavaSchedulersHook.class, System.getProperties());
+            Object impl = getPluginImplementationViaProperty(RxJavaSchedulersHook.class, getSystemPropertiesSafe());
             if (impl == null) {
                 // nothing set via properties so initialize with default
                 schedulersHook.compareAndSet(null, RxJavaSchedulersHook.getDefaultInstance());
diff --git a/src/test/java/rx/plugins/RxJavaPluginsTest.java b/src/test/java/rx/plugins/RxJavaPluginsTest.java
index 1c69ff1389..50d6944a08 100644
--- a/src/test/java/rx/plugins/RxJavaPluginsTest.java
+++ b/src/test/java/rx/plugins/RxJavaPluginsTest.java
@@ -18,6 +18,7 @@
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.mock;
 
+import java.security.Permission;
 import java.util.*;
 import java.util.concurrent.TimeUnit;
 
@@ -344,4 +345,75 @@ public void onNext(Object o) {
         assertEquals(re, errorHandler.e);
         assertEquals(1, errorHandler.count);
     }
+
+    @Test
+    public void systemPropertiesSecurityException() {
+        assertNull(RxJavaPlugins.getPluginImplementationViaProperty(Object.class, new Properties() {
+
+            private static final long serialVersionUID = -4291534158508255616L;
+
+            @Override
+            public Set<java.util.Map.Entry<Object, Object>> entrySet() {
+                return new HashSet<java.util.Map.Entry<Object, Object>>() {
+
+                    private static final long serialVersionUID = -7714005655772619143L;
+
+                    @Override
+                    public Iterator<java.util.Map.Entry<Object, Object>> iterator() {
+                        return new Iterator<java.util.Map.Entry<Object, Object>>() {
+                            @Override
+                            public boolean hasNext() {
+                                return true;
+                            }
+
+                            @Override
+                            public Map.Entry<Object,Object> next() {
+                                throw new SecurityException();
+                            };
+
+                            @Override
+                            public void remove() {
+                                throw new UnsupportedOperationException();
+                            }
+                        };
+                    }
+                };
+            }
+
+            @Override
+            public synchronized Object clone() {
+                return this;
+            }
+        }));
+    }
+
+    @Test
+    public void securityManagerDenySystemProperties() {
+        SecurityManager old = System.getSecurityManager();
+        try {
+            SecurityManager sm = new SecurityManager() {
+                @Override
+                public void checkPropertiesAccess() {
+                    throw new SecurityException();
+                }
+
+                @Override
+                public void checkPermission(Permission perm) {
+                    // allow restoring the security manager
+                }
+
+                @Override
+                public void checkPermission(Permission perm, Object context) {
+                    // allow restoring the security manager
+                }
+            };
+
+            System.setSecurityManager(sm);
+            assertTrue(RxJavaPlugins.getSystemPropertiesSafe().isEmpty());
+        } finally {
+            System.setSecurityManager(old);
+        }
+
+        assertFalse(RxJavaPlugins.getSystemPropertiesSafe().isEmpty());
+    }
 }

From a49c49f6646d75aafcdd3b0dea3dc3455e88dfc2 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 27 Jan 2018 12:28:37 +0100
Subject: [PATCH 254/263] Release 1.3.5

---
 CHANGES.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 41d2e5b164..8f01a33275 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,11 @@
 # RxJava Releases #
 
+### Version 1.3.5 - January 27, 2018 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.5%7C))
+
+#### Other
+
+- [Pull 5820](https://github.com/ReactiveX/RxJava/pull/5820): `RxJavaPlugins` lookup workaround for `System.getProperties()` access restrictions.
+
 ### Version 1.3.4 - November 19, 2017 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.4%7C))
 
 #### Bugfixes

From 2ba8bb2862255ab26c61d9a14ef17b32d2bfc484 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Piotr=20Ko=C5=82aczkowski?= <pkolaczk@datastax.com>
Date: Thu, 15 Feb 2018 11:15:43 +0100
Subject: [PATCH 255/263] Fix a race condition in
 OperatorMerge.InnerSubscriber#onError (#5851)

* Fix a race condition in OperatorMerge.InnerSubscriber#onError

Inner subscriber must queue the error first before setting done,
so that after emitLoop() removes the subscriber,
emitLoop is guaranteed to notice the error.
Otherwise it would be possible that inner subscribers count was 0,
and at the same time the error queue was empty.

* Add unit test for OperatorMerge.InnerSubscriber#onError race
---
 .../rx/internal/operators/OperatorMerge.java  |  5 +++-
 .../internal/operators/OperatorMergeTest.java | 28 +++++++++++++++++++
 2 files changed, 32 insertions(+), 1 deletion(-)

diff --git a/src/main/java/rx/internal/operators/OperatorMerge.java b/src/main/java/rx/internal/operators/OperatorMerge.java
index fa30f46b10..a52eee07e9 100644
--- a/src/main/java/rx/internal/operators/OperatorMerge.java
+++ b/src/main/java/rx/internal/operators/OperatorMerge.java
@@ -847,8 +847,11 @@ public void onNext(T t) {
         }
         @Override
         public void onError(Throwable e) {
-            done = true;
+            // Need to queue the error first before setting done, so that after emitLoop() removes the subscriber,
+            // it is guaranteed to notice the error. Otherwise it would be possible that inner subscribers count was 0,
+            // and at the same time the error queue was empty.
             parent.getOrCreateErrorQueue().offer(e);
+            done = true;
             parent.emit();
         }
         @Override
diff --git a/src/test/java/rx/internal/operators/OperatorMergeTest.java b/src/test/java/rx/internal/operators/OperatorMergeTest.java
index 7528cb88d8..bc13673f5e 100644
--- a/src/test/java/rx/internal/operators/OperatorMergeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMergeTest.java
@@ -1205,6 +1205,34 @@ public void onNext(Integer t) {
         assertTrue(latch.await(10, TimeUnit.SECONDS));
     }
 
+    @Test
+    public void testConcurrentMergeInnerError() {
+        for (int i = 0; i < 1000; i++) {
+            final TestSubscriber<Integer> ts = TestSubscriber.create();
+            final PublishSubject<Integer> ps1 = PublishSubject.create();
+            final PublishSubject<Integer> ps2 = PublishSubject.create();
+            final Exception error = new NullPointerException();
+            Action0 action1 = new Action0() {
+                @Override
+                public void call() {
+                    ps1.onNext(1);
+                    ps1.onCompleted();
+                }
+            };
+            Action0 action2 = new Action0() {
+                @Override
+                public void call() {
+                    ps2.onError(error);
+                }
+            };
+
+            Observable.mergeDelayError(ps1, ps2).subscribe(ts);
+            TestUtil.race(action1, action2);
+            ts.assertTerminalEvent();
+            ts.assertError(error);
+        }
+    }
+
     private static Action1<Integer> printCount() {
         return new Action1<Integer>() {
             long count;

From c40a06f331cfeea8ccca987edaff54a294abc07a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Piotr=20Ko=C5=82aczkowski?= <pkolaczk@datastax.com>
Date: Thu, 15 Feb 2018 19:49:26 +0100
Subject: [PATCH 256/263] Fix a race condition that may make
 OperatorMaterialize emit too many terminal notifications (#5850)

* Fix a race condition that may make OperatorMaterialize emit the
terminal notification more than once

The guards in `OperatorMaterialize.ParentSubscriber#drain` were never
working, because `busy` was actually never set to true.
Therefore it was possible that the `drain` loop was executed by
more than one thread concurrently, which could led to undefined
behavior.

This fix sets `busy` to true at the entry of `drain`.

* Add unit test for race in OperatorMaterialize

* Set sudo required in travis config
---
 .travis.yml                                   |  2 +-
 .../operators/OperatorMaterialize.java        |  1 +
 .../operators/OperatorMaterializeTest.java    | 30 +++++++++++++++++++
 3 files changed, 32 insertions(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 751937fa52..e9ae55c471 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,7 @@
 language: java
 jdk:
 - oraclejdk8
-sudo: false
+sudo: required
 # as per http://blog.travis-ci.com/2014-12-17-faster-builds-with-container-based-infrastructure/
 
 git:
diff --git a/src/main/java/rx/internal/operators/OperatorMaterialize.java b/src/main/java/rx/internal/operators/OperatorMaterialize.java
index c1d4a3b65e..ce9e1be604 100644
--- a/src/main/java/rx/internal/operators/OperatorMaterialize.java
+++ b/src/main/java/rx/internal/operators/OperatorMaterialize.java
@@ -134,6 +134,7 @@ private void drain() {
                     missed = true;
                     return;
                 }
+                busy = true;
             }
             // drain loop
             final AtomicLong localRequested = this.requested;
diff --git a/src/test/java/rx/internal/operators/OperatorMaterializeTest.java b/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
index 437593d313..a55758d25c 100644
--- a/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorMaterializeTest.java
@@ -29,9 +29,12 @@
 import rx.Notification;
 import rx.Observable;
 import rx.Subscriber;
+import rx.TestUtil;
+import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
+import rx.subjects.PublishSubject;
 
 public class OperatorMaterializeTest {
 
@@ -201,6 +204,33 @@ public void testUnsubscribeJustBeforeCompletionNotificationShouldPreventThatNoti
         ts.assertUnsubscribed();
     }
 
+    @Test
+    public void testConcurrency() {
+        for (int i = 0; i < 1000; i++) {
+            final TestSubscriber<Notification<Integer>> ts = TestSubscriber.create(0);
+            final PublishSubject<Integer> ps = PublishSubject.create();
+            Action0 publishAction = new Action0() {
+                @Override
+                public void call() {
+                    ps.onCompleted();
+                }
+            };
+
+            Action0 requestAction = new Action0() {
+                @Override
+                public void call() {
+                    ts.requestMore(1);
+                }
+            };
+
+            ps.materialize().subscribe(ts);
+            TestUtil.race(publishAction, requestAction);
+            ts.assertValueCount(1);
+            ts.assertTerminalEvent();
+            ts.assertNoErrors();
+        }
+    }
+
     private static class TestObserver extends Subscriber<Notification<String>> {
 
         boolean onCompleted;

From 6e6c5143afec6cdddf72e4e890a02a683ea14ba3 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Thu, 15 Feb 2018 20:53:01 +0100
Subject: [PATCH 257/263] Release 1.3.6

---
 CHANGES.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 8f01a33275..792c803ece 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,12 @@
 # RxJava Releases #
 
+### Version 1.3.6 - February 15, 2018 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.6%7C))
+
+#### Bugfixes
+
+- [Pull 5850](https://github.com/ReactiveX/RxJava/pull/5850): Fix a race condition that may make `OperatorMaterialize` emit the wrong signals.
+- [Pull 5851](https://github.com/ReactiveX/RxJava/pull/5851): Fix a race condition in `OperatorMerge.InnerSubscriber#onError` causing incorrect terminal event.
+
 ### Version 1.3.5 - January 27, 2018 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.5%7C))
 
 #### Other

From e467798b3b712af4161605e5bd57cb16f7e5168e Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Tue, 20 Mar 2018 01:21:40 +1100
Subject: [PATCH 258/263] 1.x: fix and deprecate evicting groupBy and add new
 overload (#5917)

* 1.x: fix bug and deprecate groupBy overload with evictingMapFactory, add new groupBy evicting overload (#5868)

* groupBy, do a null check on g because cancel(K) could have cleared the map
---
 build.gradle                                  |   2 +-
 src/main/java/rx/Observable.java              |  75 ++-
 .../internal/operators/OperatorGroupBy.java   |  24 +-
 .../operators/OperatorGroupByEvicting.java    | 605 ++++++++++++++++++
 .../operators/OperatorGroupByTest.java        | 228 +++++++
 5 files changed, 928 insertions(+), 6 deletions(-)
 create mode 100644 src/main/java/rx/internal/operators/OperatorGroupByEvicting.java

diff --git a/build.gradle b/build.gradle
index 570ceb242f..8d0d2fa087 100644
--- a/build.gradle
+++ b/build.gradle
@@ -26,7 +26,7 @@ dependencies {
 
     testCompile 'junit:junit:4.12'
     testCompile 'org.mockito:mockito-core:1.10.19'
-    testCompile 'com.google.guava:guava:19.0'
+    testCompile 'com.google.guava:guava:24.0-jre'
     testCompile 'com.pushtorefresh.java-private-constructor-checker:checker:1.2.0'
 
     perfCompile 'org.openjdk.jmh:jmh-core:1.11.3'
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
index 5d1896008e..99e84ec609 100644
--- a/src/main/java/rx/Observable.java
+++ b/src/main/java/rx/Observable.java
@@ -7275,7 +7275,7 @@ public final void forEach(final Action1<? super T> onNext, final Action1<Throwab
      * @see <a href="http://reactivex.io/documentation/operators/groupby.html">ReactiveX operators documentation: GroupBy</a>
      */
     public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? super T, ? extends K> keySelector, final Func1<? super T, ? extends R> elementSelector) {
-        return lift(new OperatorGroupBy<T, K, R>(keySelector, elementSelector));
+        return lift(new OperatorGroupByEvicting<T, K, R>(keySelector, elementSelector));
     }
 
     /**
@@ -7334,7 +7334,12 @@ public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? su
      *             if {@code evictingMapFactory} is null
      * @see <a href="http://reactivex.io/documentation/operators/groupby.html">ReactiveX operators documentation: GroupBy</a>
      * @since 1.3
+     * @deprecated since 1.3.7, use {@link #groupBy(Func1, Func1, int, boolean, Func1)} 
+     *             instead which uses much less memory. Please take note of the 
+     *             usage difference involving the evicting action which now expects
+     *             the value from the map instead of the key.
      */
+    @Deprecated
     public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? super T, ? extends K> keySelector,
             final Func1<? super T, ? extends R> elementSelector, final Func1<Action1<K>, Map<K, Object>> evictingMapFactory) {
         if (evictingMapFactory == null) {
@@ -7369,6 +7374,72 @@ public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? su
      *
      * @param keySelector
      *            a function that extracts the key for each item
+     * @param elementSelector
+     *            a function that extracts the return element for each item
+     * @param bufferSize 
+     *            the size of the buffer ({@link RxRingBuffer.SIZE} may be suitable).
+     * @param delayError
+     *            if and only if false then onError emissions can shortcut onNext emissions (emissions may be buffered)
+     * @param evictingMapFactory
+     *            a function that given an eviction action returns a {@link Map} instance that will be used to assign 
+     *            items to the appropriate {@code GroupedObservable}s. The {@code Map} instance must be thread-safe 
+     *            and any eviction must trigger a call to the supplied action (synchronously or asynchronously). 
+     *            This can be used to limit the size of the map by evicting entries by map maximum size or access time for 
+     *            instance. Here's an example using Guava's {@code CacheBuilder} from v24.0:
+     *            <pre>
+     *            {@code
+     *            Func1<Action1<Object>, Map<K, Object>> mapFactory 
+     *              = action -> CacheBuilder.newBuilder()
+     *                  .maximumSize(1000)
+     *                  .expireAfterAccess(12, TimeUnit.HOURS)
+     *                  .removalListener(entry -> action.call(entry.getValue()))
+     *                  .<K, Object> build().asMap();
+     *            }
+     *            </pre>
+     *            
+     * @param <K>
+     *            the key type
+     * @param <R>
+     *            the element type
+     * @return an {@code Observable} that emits {@link GroupedObservable}s, each of which corresponds to a
+     *         unique key value and each of which emits those items from the source Observable that share that
+     *         key value
+     * @throws NullPointerException
+     *             if {@code evictingMapFactory} is null
+     * @see <a href="http://reactivex.io/documentation/operators/groupby.html">ReactiveX operators documentation: GroupBy</a>
+     * @since 1.3.7
+     */
+    @Experimental
+    public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? super T, ? extends K> keySelector, 
+            final Func1<? super T, ? extends R> elementSelector, int bufferSize, boolean delayError, 
+            final Func1<Action1<Object>, Map<K, Object>> evictingMapFactory) {
+        if (evictingMapFactory == null) {
+            throw new NullPointerException("evictingMapFactory cannot be null");
+        }
+        return lift(new OperatorGroupByEvicting<T, K, R>(
+                keySelector, elementSelector, bufferSize, delayError, evictingMapFactory));
+    }
+    
+    /**
+     * Groups the items emitted by an {@code Observable} according to a specified criterion, and emits these
+     * grouped items as {@link GroupedObservable}s. The emitted {@code GroupedObservable} allows only a single 
+     * {@link Subscriber} during its lifetime and if this {@code Subscriber} unsubscribes before the 
+     * source terminates, the next emission by the source having the same key will trigger a new 
+     * {@code GroupedObservable} emission.
+     * <p>
+     * <img width="640" height="360" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/groupBy.png" alt="">
+     * <p>
+     * <em>Note:</em> A {@link GroupedObservable} will cache the items it is to emit until such time as it
+     * is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those
+     * {@code GroupedObservable}s that do not concern you. Instead, you can signal to them that they may
+     * discard their buffers by applying an operator like {@link #ignoreElements} to them.
+     * <dl>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code groupBy} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     * 
+     * @param keySelector
+     *            a function that extracts the key for each item
      * @param <K>
      *            the key type
      * @return an {@code Observable} that emits {@link GroupedObservable}s, each of which corresponds to a
@@ -7377,7 +7448,7 @@ public final <K, R> Observable<GroupedObservable<K, R>> groupBy(final Func1<? su
      * @see <a href="http://reactivex.io/documentation/operators/groupby.html">ReactiveX operators documentation: GroupBy</a>
      */
     public final <K> Observable<GroupedObservable<K, T>> groupBy(final Func1<? super T, ? extends K> keySelector) {
-        return lift(new OperatorGroupBy<T, K, T>(keySelector));
+        return lift(new OperatorGroupByEvicting<T, K, T>(keySelector));
     }
 
     /**
diff --git a/src/main/java/rx/internal/operators/OperatorGroupBy.java b/src/main/java/rx/internal/operators/OperatorGroupBy.java
index 8892f0d4d0..5d6ec2f556 100644
--- a/src/main/java/rx/internal/operators/OperatorGroupBy.java
+++ b/src/main/java/rx/internal/operators/OperatorGroupBy.java
@@ -42,13 +42,16 @@
  *            the source and group value type
  * @param <V>
  *            the value type of the groups
+ * @deprecated 
+ *            since 1.3.7, use {@link OperatorGroupByEvicting} instead
  */
+@Deprecated
 public final class OperatorGroupBy<T, K, V> implements Operator<GroupedObservable<K, V>, T> {
     final Func1<? super T, ? extends K> keySelector;
     final Func1<? super T, ? extends V> valueSelector;
     final int bufferSize;
     final boolean delayError;
-    final Func1<Action1<K>, Map<K, Object>> mapFactory;
+    final Func1<Action1<K>, Map<K, Object>> mapFactory; //nullable
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public OperatorGroupBy(Func1<? super T, ? extends K> keySelector) {
@@ -116,6 +119,10 @@ public static final class GroupBySubscriber<T, K, V>
         final int bufferSize;
         final boolean delayError;
         final Map<Object, GroupedUnicast<K, V>> groups;
+        
+        // double store the groups to workaround the bug in the 
+        // signature of groupBy with evicting map factory
+        final Map<Object, GroupedUnicast<K, V>> groupsCopy;
         final Queue<GroupedObservable<K, V>> queue;
         final GroupByProducer producer;
         final Queue<K> evictedKeys;
@@ -134,7 +141,7 @@ public static final class GroupBySubscriber<T, K, V>
         volatile boolean done;
 
         final AtomicInteger wip;
-
+        
         public GroupBySubscriber(Subscriber<? super GroupedObservable<K, V>> actual, Func1<? super T, ? extends K> keySelector,
                 Func1<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError,
                 Func1<Action1<K>, Map<K, Object>> mapFactory) {
@@ -158,6 +165,7 @@ public GroupBySubscriber(Subscriber<? super GroupedObservable<K, V>> actual, Fun
                 this.evictedKeys = new ConcurrentLinkedQueue<K>();
                 this.groups = createMap(mapFactory, new EvictionAction<K>(evictedKeys));
             }
+            this.groupsCopy = new ConcurrentHashMap<Object, GroupedUnicast<K, V>>();
         }
 
         static class EvictionAction<K> implements Action1<K> {
@@ -211,6 +219,9 @@ public void onNext(T t) {
                 if (!cancelled.get()) {
                     group = GroupedUnicast.createWith(key, bufferSize, this, delayError);
                     groups.put(mapKey, group);
+                    if (evictedKeys != null) {
+                        groupsCopy.put(mapKey, group);
+                    }
 
                     groupCount.getAndIncrement();
 
@@ -234,7 +245,9 @@ public void onNext(T t) {
             if (evictedKeys != null) {
                 K evictedKey;
                 while ((evictedKey = evictedKeys.poll()) != null) {
-                    GroupedUnicast<K, V> g = groups.get(evictedKey);
+                    GroupedUnicast<K, V> g = groupsCopy.remove(evictedKey);
+                    // do a null check on g because cancel(K) could have cleared
+                    // the map
                     if (g != null) {
                         g.onComplete();
                     }
@@ -270,6 +283,7 @@ public void onCompleted() {
             }
             groups.clear();
             if (evictedKeys != null) {
+                groupsCopy.clear();
                 evictedKeys.clear();
             }
 
@@ -304,6 +318,9 @@ public void cancel(K key) {
                     unsubscribe();
                 }
             }
+            if (evictedKeys != null) {
+                groupsCopy.remove(mapKey);
+            }
         }
 
         void drain() {
@@ -364,6 +381,7 @@ void errorAll(Subscriber<? super GroupedObservable<K, V>> a, Queue<?> q, Throwab
             List<GroupedUnicast<K, V>> list = new ArrayList<GroupedUnicast<K, V>>(groups.values());
             groups.clear();
             if (evictedKeys != null) {
+                groupsCopy.clear();
                 evictedKeys.clear();
             }
 
diff --git a/src/main/java/rx/internal/operators/OperatorGroupByEvicting.java b/src/main/java/rx/internal/operators/OperatorGroupByEvicting.java
new file mode 100644
index 0000000000..d02ecf5d39
--- /dev/null
+++ b/src/main/java/rx/internal/operators/OperatorGroupByEvicting.java
@@ -0,0 +1,605 @@
+/**
+ * Copyright 2018 Netflix, Inc.
+ * 
+ * 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 rx.internal.operators;
+
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+import rx.*;
+import rx.Observable.*;
+import rx.exceptions.Exceptions;
+import rx.functions.*;
+import rx.internal.producers.ProducerArbiter;
+import rx.internal.util.*;
+import rx.observables.GroupedObservable;
+import rx.plugins.RxJavaHooks;
+import rx.observers.Subscribers;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * Groups the items emitted by an Observable according to a specified criterion, and emits these
+ * grouped items as Observables, one Observable per group.
+ * <p>
+ * <img width="640" height="360" src="https://raw.githubusercontent.com/wiki/ReactiveX/RxJava/images/rx-operators/groupBy.png" alt="">
+ *
+ * @param <K>
+ *            the key type
+ * @param <T>
+ *            the source and group value type
+ * @param <V>
+ *            the value type of the groups
+ */
+public final class OperatorGroupByEvicting<T, K, V> implements Operator<GroupedObservable<K, V>, T>{
+    
+    final Func1<? super T, ? extends K> keySelector;
+    final Func1<? super T, ? extends V> valueSelector;
+    final int bufferSize;
+    final boolean delayError;
+    final Func1<Action1<Object>, Map<K, Object>> mapFactory; //nullable
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public OperatorGroupByEvicting(Func1<? super T, ? extends K> keySelector) {
+        this(keySelector, (Func1)UtilityFunctions.<T>identity(), RxRingBuffer.SIZE, false, null);
+    }
+
+    public OperatorGroupByEvicting(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
+        this(keySelector, valueSelector, RxRingBuffer.SIZE, false, null);
+    }
+    
+    public OperatorGroupByEvicting(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError, Func1<Action1<Object>, Map<K, Object>> mapFactory) {
+        this.keySelector = keySelector;
+        this.valueSelector = valueSelector;
+        this.bufferSize = bufferSize;
+        this.delayError = delayError;
+        this.mapFactory = mapFactory;
+    }
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super GroupedObservable<K, V>> child) {
+        Map<K, GroupedUnicast<K, V>> groups;
+        Queue<GroupedUnicast<K, V>> evictedGroups;
+        
+        if (mapFactory == null) {
+            evictedGroups = null;
+            groups = new ConcurrentHashMap<K, GroupedUnicast<K, V>>();
+        } else {
+            evictedGroups = new ConcurrentLinkedQueue<GroupedUnicast<K, V>>();
+            Action1<Object> evictionAction = (Action1<Object>)(Action1<?>) 
+                    new EvictionAction<K, V>(evictedGroups);
+            try {
+                groups = (Map<K, GroupedUnicast<K,V>>)(Map<Object, ?>) 
+                        mapFactory.call((Action1<Object>)(Action1<?>) evictionAction);
+            } catch (Throwable ex) {
+                //Can reach here because mapFactory.call() may throw
+                Exceptions.throwOrReport(ex, child);
+                Subscriber<? super T> parent2 = Subscribers.empty();
+                parent2.unsubscribe();
+                return parent2;
+            }
+        }
+        final GroupBySubscriber<T, K, V> parent = new GroupBySubscriber<T, K, V>(
+                child, keySelector, valueSelector, bufferSize, delayError, groups, evictedGroups);
+
+        child.add(Subscriptions.create(new Action0() {
+            @Override
+            public void call() {
+                parent.cancel();
+            }
+        }));
+
+        child.setProducer(parent.producer);
+        
+        return parent;
+    }
+
+    public static final class GroupByProducer implements Producer {
+        final GroupBySubscriber<?, ?, ?> parent;
+        
+        public GroupByProducer(GroupBySubscriber<?, ?, ?> parent) {
+            this.parent = parent;
+        }
+        @Override
+        public void request(long n) {
+            parent.requestMore(n);
+        }
+    }
+    
+    public static final class GroupBySubscriber<T, K, V> 
+    extends Subscriber<T> {
+        final Subscriber<? super GroupedObservable<K, V>> actual;
+        final Func1<? super T, ? extends K> keySelector;
+        final Func1<? super T, ? extends V> valueSelector;
+        final int bufferSize;
+        final boolean delayError;
+        final Map<K, GroupedUnicast<K, V>> groups;
+        final Queue<GroupedUnicast<K, V>> queue;
+        final GroupByProducer producer;
+        final Queue<GroupedUnicast<K, V>> evictedGroups;
+        
+        static final Object NULL_KEY = new Object();
+        
+        final ProducerArbiter s;
+        
+        final AtomicBoolean cancelled;
+
+        final AtomicLong requested;
+
+        final AtomicInteger groupCount;
+        
+        Throwable error;
+        volatile boolean done;
+
+        final AtomicInteger wip;
+        
+        public GroupBySubscriber(Subscriber<? super GroupedObservable<K, V>> actual, Func1<? super T, ? extends K> keySelector, 
+                Func1<? super T, ? extends V> valueSelector, int bufferSize, boolean delayError, Map<K, GroupedUnicast<K, V>> groups, 
+                Queue<GroupedUnicast<K, V>> evictedGroups) {
+            this.actual = actual;
+            this.keySelector = keySelector;
+            this.valueSelector = valueSelector;
+            this.bufferSize = bufferSize;
+            this.delayError = delayError;
+            this.queue = new ConcurrentLinkedQueue<GroupedUnicast<K, V>>();
+            this.s = new ProducerArbiter();
+            this.s.request(bufferSize);
+            this.producer = new GroupByProducer(this);
+            this.cancelled = new AtomicBoolean();
+            this.requested = new AtomicLong();
+            this.groupCount = new AtomicInteger(1);
+            this.wip = new AtomicInteger();
+            this.groups = groups;
+            this.evictedGroups = evictedGroups;
+        }
+        
+        @Override
+        public void setProducer(Producer s) {
+            this.s.setProducer(s);
+        }
+        
+        @Override
+        public void onNext(T t) {
+            if (done) {
+                return;
+            }
+
+            final Queue<GroupedUnicast<K, V>> q = this.queue;
+            final Subscriber<? super GroupedObservable<K, V>> a = this.actual;
+
+            K key;
+            try {
+                key = keySelector.call(t);
+            } catch (Throwable ex) {
+                unsubscribe();
+                errorAll(a, q, ex);
+                return;
+            }
+            
+            boolean newGroup = false;
+            @SuppressWarnings("unchecked")
+            K mapKey = key != null ? key : (K) NULL_KEY;
+            GroupedUnicast<K, V> group = groups.get(mapKey);
+            if (group == null) {
+                // if the main has been cancelled, stop creating groups
+                // and skip this value
+                if (!cancelled.get()) {
+                    group = GroupedUnicast.createWith(key, bufferSize, this, delayError);
+                    groups.put(mapKey, group);
+                    
+                    groupCount.getAndIncrement();
+                    
+                    newGroup = false;
+                    q.offer(group);
+                    drain();
+                } else {
+                    return;
+                }
+            }
+            
+            V v;
+            try {
+                v = valueSelector.call(t);
+            } catch (Throwable ex) {
+                unsubscribe();
+                errorAll(a, q, ex);
+                return;
+            }
+
+            group.onNext(v);
+            
+            if (evictedGroups != null) {
+                GroupedUnicast<K, V> evictedGroup;
+                while ((evictedGroup = evictedGroups.poll()) != null) {
+                    evictedGroup.onComplete();
+                }
+            }
+
+            if (newGroup) {
+                q.offer(group);
+                drain();
+            }
+        }
+        
+        @Override
+        public void onError(Throwable t) {
+            if (done) {
+                RxJavaHooks.onError(t);
+                return;
+            }
+            error = t;
+            done = true;
+            groupCount.decrementAndGet();
+            drain();
+        }
+        
+        @Override
+        public void onCompleted() {
+            if (done) {
+                return;
+            }
+
+            for (GroupedUnicast<K, V> e : groups.values()) {
+                e.onComplete();
+            }
+            groups.clear();
+            if (evictedGroups != null) {
+                evictedGroups.clear();
+            }
+
+            done = true;
+            groupCount.decrementAndGet();
+            drain();
+        }
+
+        public void requestMore(long n) {
+            if (n < 0) {
+                throw new IllegalArgumentException("n >= 0 required but it was " + n);
+            }
+            
+            BackpressureUtils.getAndAddRequest(requested, n);
+            drain();
+        }
+        
+        public void cancel() {
+            // cancelling the main source means we don't want any more groups
+            // but running groups still require new values
+            if (cancelled.compareAndSet(false, true)) {
+                if (groupCount.decrementAndGet() == 0) {
+                    unsubscribe();
+                }
+            }
+        }
+        
+        public void cancel(K key) {
+            Object mapKey = key != null ? key : NULL_KEY;
+            if (groups.remove(mapKey) != null) {
+                if (groupCount.decrementAndGet() == 0) {
+                    unsubscribe();
+                }
+            }
+        }
+        
+        void drain() {
+            if (wip.getAndIncrement() != 0) {
+                return;
+            }
+            
+            int missed = 1;
+            
+            final Queue<GroupedUnicast<K, V>> q = this.queue;
+            final Subscriber<? super GroupedObservable<K, V>> a = this.actual;
+            
+            for (;;) {
+                
+                if (checkTerminated(done, q.isEmpty(), a, q)) {
+                    return;
+                }
+                
+                long r = requested.get();
+                boolean unbounded = r == Long.MAX_VALUE;
+                long e = 0L;
+                
+                while (r != 0) {
+                    boolean d = done;
+                    
+                    GroupedObservable<K, V> t = q.poll();
+                    
+                    boolean empty = t == null;
+                    
+                    if (checkTerminated(d, empty, a, q)) {
+                        return;
+                    }
+                    
+                    if (empty) {
+                        break;
+                    }
+
+                    a.onNext(t);
+                    
+                    r--;
+                    e--;
+                }
+                
+                if (e != 0L) {
+                    if (!unbounded) {
+                        requested.addAndGet(e);
+                    }
+                    s.request(-e);
+                }
+                
+                missed = wip.addAndGet(-missed);
+                if (missed == 0) {
+                    break;
+                }
+            }
+        }
+        
+        void errorAll(Subscriber<? super GroupedObservable<K, V>> a, Queue<?> q, Throwable ex) {
+            q.clear();
+            List<GroupedUnicast<K, V>> list = new ArrayList<GroupedUnicast<K, V>>(groups.values());
+            groups.clear();
+            if (evictedGroups != null) { 
+                evictedGroups.clear();
+            }
+            
+            for (GroupedUnicast<K, V> e : list) {
+                e.onError(ex);
+            }
+            
+            a.onError(ex);
+        }
+        
+        boolean checkTerminated(boolean d, boolean empty, 
+                Subscriber<? super GroupedObservable<K, V>> a, Queue<?> q) {
+            if (d) {
+                Throwable err = error;
+                if (err != null) {
+                    errorAll(a, q, err);
+                    return true;
+                } else
+                if (empty) {
+                    actual.onCompleted();
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+    
+    static class EvictionAction<K, V> implements Action1<GroupedUnicast<K, V>> {
+
+        final Queue<GroupedUnicast<K, V>> evictedGroups;
+
+        EvictionAction(Queue<GroupedUnicast<K, V>> evictedGroups) {
+            this.evictedGroups = evictedGroups;
+        }
+        
+        @Override
+        public void call(GroupedUnicast<K, V> group) {
+            evictedGroups.offer(group);
+        }
+    }
+    
+    static final class GroupedUnicast<K, T> extends GroupedObservable<K, T> {
+        
+        public static <T, K> GroupedUnicast<K, T> createWith(K key, int bufferSize, GroupBySubscriber<?, K, T> parent, boolean delayError) {
+            State<T, K> state = new State<T, K>(bufferSize, parent, key, delayError);
+            return new GroupedUnicast<K, T>(key, state);
+        }
+        
+        final State<T, K> state;
+        
+        protected GroupedUnicast(K key, State<T, K> state) {
+            super(key, state);
+            this.state = state;
+        }
+        
+        public void onNext(T t) {
+            state.onNext(t);
+        }
+        
+        public void onError(Throwable e) {
+            state.onError(e);
+        }
+        
+        public void onComplete() {
+            state.onComplete();
+        }
+    }
+    
+    static final class State<T, K> extends AtomicInteger implements Producer, Subscription, OnSubscribe<T> {
+        /** */
+        private static final long serialVersionUID = -3852313036005250360L;
+
+        final K key;
+        final Queue<Object> queue;
+        final GroupBySubscriber<?, K, T> parent;
+        final boolean delayError;
+        
+        final AtomicLong requested;
+        
+        volatile boolean done;
+        Throwable error;
+        
+        final AtomicBoolean cancelled;
+
+        final AtomicReference<Subscriber<? super T>> actual;
+
+        final AtomicBoolean once;
+
+        
+        public State(int bufferSize, GroupBySubscriber<?, K, T> parent, K key, boolean delayError) {
+            this.queue = new ConcurrentLinkedQueue<Object>();
+            this.parent = parent;
+            this.key = key;
+            this.delayError = delayError;
+            this.cancelled = new AtomicBoolean();
+            this.actual = new AtomicReference<Subscriber<? super T>>();
+            this.once = new AtomicBoolean();
+            this.requested = new AtomicLong();
+        }
+        
+        @Override
+        public void request(long n) {
+            if (n < 0) {
+                throw new IllegalArgumentException("n >= required but it was " + n);
+            }
+            if (n != 0L) {
+                BackpressureUtils.getAndAddRequest(requested, n);
+                drain();
+            }
+        }
+        
+        @Override
+        public boolean isUnsubscribed() {
+            return cancelled.get();
+        }
+        
+        @Override
+        public void unsubscribe() {
+            if (cancelled.compareAndSet(false, true)) {
+                if (getAndIncrement() == 0) {
+                    parent.cancel(key);
+                }
+            }
+        }
+        
+        @Override
+        public void call(Subscriber<? super T> s) {
+            if (once.compareAndSet(false, true)) {
+                s.add(this);
+                s.setProducer(this);
+                actual.lazySet(s);
+                drain();
+            } else {
+                s.onError(new IllegalStateException("Only one Subscriber allowed!"));
+            }
+        }
+
+        public void onNext(T t) {
+            if (t == null) {
+                error = new NullPointerException();
+                done = true;
+            } else {
+                queue.offer(NotificationLite.next(t));
+            }
+            drain();
+        }
+        
+        public void onError(Throwable e) {
+            error = e;
+            done = true;
+            drain();
+        }
+        
+        public void onComplete() {
+            done = true;
+            drain();
+        }
+
+        void drain() {
+            if (getAndIncrement() != 0) {
+                return;
+            }
+            int missed = 1;
+            
+            final Queue<Object> q = queue;
+            final boolean delayError = this.delayError;
+            Subscriber<? super T> a = actual.get();
+            for (;;) {
+                if (a != null) {
+                    if (checkTerminated(done, q.isEmpty(), a, delayError)) {
+                        return;
+                    }
+                    
+                    long r = requested.get();
+                    boolean unbounded = r == Long.MAX_VALUE;
+                    long e = 0;
+                    
+                    while (r != 0L) {
+                        boolean d = done;
+                        Object v = q.poll();
+                        boolean empty = v == null;
+                        
+                        if (checkTerminated(d, empty, a, delayError)) {
+                            return;
+                        }
+                        
+                        if (empty) {
+                            break;
+                        }
+                        
+                        a.onNext(NotificationLite.<T>getValue(v));
+                        
+                        r--;
+                        e--;
+                    }
+                    
+                    if (e != 0L) {
+                        if (!unbounded) {
+                            requested.addAndGet(e);
+                        }
+                        parent.s.request(-e);
+                    }
+                }
+                
+                missed = addAndGet(-missed);
+                if (missed == 0) {
+                    break;
+                }
+                if (a == null) {
+                    a = actual.get();
+                }
+            }
+        }
+        
+        boolean checkTerminated(boolean d, boolean empty, Subscriber<? super T> a, boolean delayError) {
+            if (cancelled.get()) {
+                queue.clear();
+                parent.cancel(key);
+                return true;
+            }
+            
+            if (d) {
+                if (delayError) {
+                    if (empty) {
+                        Throwable e = error;
+                        if (e != null) {
+                            a.onError(e);
+                        } else {
+                            a.onCompleted();
+                        }
+                        return true;
+                    }
+                } else {
+                    Throwable e = error;
+                    if (e != null) {
+                        queue.clear();
+                        a.onError(e);
+                        return true;
+                    } else
+                    if (empty) {
+                        a.onCompleted();
+                        return true;
+                    }
+                }
+            }
+            
+            return false;
+        }
+    }
+}
diff --git a/src/test/java/rx/internal/operators/OperatorGroupByTest.java b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
index 7fd6ab0a2e..b9c2bc6ece 100644
--- a/src/test/java/rx/internal/operators/OperatorGroupByTest.java
+++ b/src/test/java/rx/internal/operators/OperatorGroupByTest.java
@@ -39,8 +39,10 @@
 import rx.functions.*;
 import rx.internal.util.*;
 import rx.observables.GroupedObservable;
+import rx.observers.AssertableSubscriber;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
+import rx.subjects.PublishSubject;
 
 public class OperatorGroupByTest {
 
@@ -2047,4 +2049,230 @@ public Observable<Integer> call(GroupedObservable<Integer, Integer> v) {
         assertTrue("" + c, c > 0);
         assertTrue("" + c, c < 10000);
     }
+    
+    @Test
+    public void groupByEvictingMapFactoryThrows() {
+        final RuntimeException ex = new RuntimeException("boo");
+        Func1<Action1<Object>, Map<Integer, Object>> evictingMapFactory =  //
+                new Func1<Action1<Object>, Map<Integer, Object>>() {
+
+                    @Override
+                    public Map<Integer, Object> call(final Action1<Object> notify) {
+                        throw ex;
+                    }
+                };
+        Observable.just(1)
+          .groupBy(UtilityFunctions.<Integer>identity(), UtilityFunctions.identity(), 16, true, evictingMapFactory)
+          .test()
+          .assertNoValues()
+          .assertError(ex);
+    }
+
+    @Test
+    public void groupByEvictingMapFactoryExpiryCompletesGroupedFlowable() {
+        final List<Integer> completed = new CopyOnWriteArrayList<Integer>();
+        Func1<Action1<Object>, Map<Integer, Object>> evictingMapFactory = createEvictingMapFactorySynchronousOnly(1);
+        PublishSubject<Integer> subject = PublishSubject.create();
+        AssertableSubscriber<Integer> ts = subject
+                .groupBy(UtilityFunctions.<Integer>identity(), UtilityFunctions.<Integer>identity(), 16, true, evictingMapFactory)
+                .flatMap(addCompletedKey(completed))
+                .test();
+        subject.onNext(1);
+        subject.onNext(2);
+        subject.onNext(3);
+        ts.assertValues(1, 2, 3)
+          .assertNoTerminalEvent();
+        assertEquals(Arrays.asList(1, 2), completed);
+        //ensure coverage of the code that clears the evicted queue
+        subject.onCompleted();
+        ts.assertCompleted();
+        ts.assertValueCount(3);
+    }
+
+    private static final Func1<Integer, Integer> mod5 = new Func1<Integer, Integer>() {
+
+        @Override
+        public Integer call(Integer n) {
+            return n % 5;
+        }
+    };
+
+    @Test
+    public void groupByEvictingMapFactoryWithExpiringGuavaCacheDemonstrationCodeForUseInJavadoc() {
+        //javadoc will be a version of this using lambdas and without assertions
+        final List<Integer> completed = new CopyOnWriteArrayList<Integer>();
+        //size should be less than 5 to notice the effect
+        Func1<Action1<Object>, Map<Integer, Object>> evictingMapFactory = createEvictingMapFactoryGuava(3);
+        int numValues = 1000;
+        Observable.range(1, numValues)
+            .groupBy(mod5, UtilityFunctions.<Integer>identity(), 16, true, evictingMapFactory)
+            .flatMap(addCompletedKey(completed))
+            .test()
+            .assertCompleted()
+            .assertValueCount(numValues);
+        //the exact eviction behaviour of the guava cache is not specified so we make some approximate tests
+        assertTrue(completed.size() > numValues * 0.9);
+    }
+
+    @Test
+    public void groupByEvictingMapFactoryEvictionQueueClearedOnErrorCoverageOnly() {
+        Func1<Action1<Object>, Map<Integer, Object>> evictingMapFactory = createEvictingMapFactorySynchronousOnly(1);
+        PublishSubject<Integer> subject = PublishSubject.create();
+        AssertableSubscriber<Integer> ts = subject
+                .groupBy(UtilityFunctions.<Integer>identity(), UtilityFunctions.<Integer>identity(), 16, true, evictingMapFactory)
+                .flatMap(new Func1<GroupedObservable<Integer, Integer>, Observable<Integer>>() {
+                    @Override
+                    public Observable<Integer> call(GroupedObservable<Integer, Integer> g) {
+                        return g;
+                    }
+                })
+                .test();
+        RuntimeException ex = new RuntimeException();
+        //ensure coverage of the code that clears the evicted queue
+        subject.onError(ex);
+        ts.assertNoValues()
+          .assertError(ex);
+    }
+
+    private static Func1<GroupedObservable<Integer, Integer>, Observable<? extends Integer>> addCompletedKey(
+            final List<Integer> completed) {
+        return new Func1<GroupedObservable<Integer, Integer>, Observable<? extends Integer>>() {
+            @Override
+            public Observable<? extends Integer> call(final GroupedObservable<Integer, Integer> g) {
+                return g.doOnCompleted(new Action0() {
+                    @Override
+                    public void call()  {
+                        completed.add(g.getKey());
+                    }
+                });
+            }
+        };
+    }
+
+    //not thread safe
+    private static final class SingleThreadEvictingHashMap<K,V> implements Map<K,V> {
+
+        private final List<K> list = new ArrayList<K>();
+        private final Map<K,V> map = new HashMap<K,V>();
+        private final int maxSize;
+        private final Action1<V> evictedListener;
+
+        SingleThreadEvictingHashMap(int maxSize, Action1<V> evictedListener) {
+            this.maxSize = maxSize;
+            this.evictedListener = evictedListener;
+        }
+
+        @Override
+        public int size() {
+            return map.size();
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return map.isEmpty();
+        }
+
+        @Override
+        public boolean containsKey(Object key) {
+            return map.containsKey(key);
+        }
+
+        @Override
+        public boolean containsValue(Object value) {
+            return map.containsValue(value);
+        }
+
+        @Override
+        public V get(Object key) {
+            return map.get(key);
+        }
+
+        @Override
+        public V put(K key, V value) {
+            list.remove(key);
+            V v;
+            if (maxSize > 0 && list.size() == maxSize) {
+                //remove first
+                K k = list.get(0);
+                list.remove(0);
+                v = map.remove(k);
+            } else {
+                v = null;
+            }
+            list.add(key);
+            V result = map.put(key, value);
+            if (v != null) {
+                evictedListener.call(v);
+            }
+            return result;
+        }
+
+        @Override
+        public V remove(Object key) {
+            list.remove(key);
+            return map.remove(key);
+        }
+
+        @Override
+        public void putAll(Map<? extends K, ? extends V> m) {
+           for (Entry<? extends K, ? extends V> entry: m.entrySet()) {
+               put(entry.getKey(), entry.getValue());
+           }
+        }
+
+        @Override
+        public void clear() {
+            list.clear();
+            map.clear();
+        }
+
+        @Override
+        public Set<K> keySet() {
+            return map.keySet();
+        }
+
+        @Override
+        public Collection<V> values() {
+            return map.values();
+        }
+
+        @Override
+        public Set<Entry<K, V>> entrySet() {
+            return map.entrySet();
+        }
+    }
+
+    private static Func1<Action1<Object>, Map<Integer, Object>> createEvictingMapFactoryGuava(final int maxSize) {
+        Func1<Action1<Object>, Map<Integer, Object>> evictingMapFactory =  //
+                new Func1<Action1<Object>, Map<Integer, Object>>() {
+
+            @Override
+            public Map<Integer, Object> call(final Action1<Object> notify) {
+                return CacheBuilder.newBuilder() //
+                        .maximumSize(maxSize) //
+                        .removalListener(new RemovalListener<Integer, Object>() {
+                            @Override
+                            public void onRemoval(RemovalNotification<Integer,Object> notification) {
+                                notify.call(notification.getValue());
+                            }})
+                        .<Integer, Object> build()
+                        .asMap();
+            }};
+        return evictingMapFactory;
+    }
+
+    private static Func1<Action1<Object>, Map<Integer, Object>> createEvictingMapFactorySynchronousOnly(final int maxSize) {
+        Func1<Action1<Object>, Map<Integer, Object>> evictingMapFactory =  //
+                new Func1<Action1<Object>, Map<Integer, Object>>() {
+
+                    @Override
+                    public Map<Integer, Object> call(final Action1<Object> notify) {
+                        return new SingleThreadEvictingHashMap<Integer,Object>(maxSize, new Action1<Object>() {
+                                    @Override
+                                    public void call(Object object) {
+                                        notify.call(object);
+                                    }});
+                    }};
+        return evictingMapFactory;
+    }
 }

From 0641802a4ff9429abc96fb02e926cddcff6ce7e7 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Wed, 21 Mar 2018 17:44:07 +0100
Subject: [PATCH 259/263] Release 1.3.7

---
 CHANGES.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 792c803ece..40d826708e 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,11 @@
 # RxJava Releases #
 
+### Version 1.3.7 - March 21, 2018 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.7%7C))
+
+#### Bugfixes
+
+- [Pull 5917](https://github.com/ReactiveX/RxJava/pull/5917): Fix and deprecate evicting `groupBy` and add a new overload with the corrected signature.
+
 ### Version 1.3.6 - February 15, 2018 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.6%7C))
 
 #### Bugfixes

From 3aad9a62ff1db8904812085cb1818eb13f652ecc Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Mon, 26 Mar 2018 15:45:52 +0200
Subject: [PATCH 260/263] 1.x: Fix take() to route late errors to RxJavaHooks
 (#5935)

---
 .../rx/internal/operators/OperatorTake.java   |  3 ++
 .../internal/operators/OperatorTakeTest.java  | 40 ++++++++++++++++++-
 2 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/src/main/java/rx/internal/operators/OperatorTake.java b/src/main/java/rx/internal/operators/OperatorTake.java
index 0be75b4f2c..d49f155d9d 100644
--- a/src/main/java/rx/internal/operators/OperatorTake.java
+++ b/src/main/java/rx/internal/operators/OperatorTake.java
@@ -19,6 +19,7 @@
 
 import rx.*;
 import rx.Observable.Operator;
+import rx.plugins.RxJavaHooks;
 
 /**
  * An {@code Observable} that emits the first {@code num} items emitted by the source {@code Observable}.
@@ -66,6 +67,8 @@ public void onError(Throwable e) {
                     } finally {
                         unsubscribe();
                     }
+                } else {
+                    RxJavaHooks.onError(e);
                 }
             }
 
diff --git a/src/test/java/rx/internal/operators/OperatorTakeTest.java b/src/test/java/rx/internal/operators/OperatorTakeTest.java
index edf17bac10..0885a8b343 100644
--- a/src/test/java/rx/internal/operators/OperatorTakeTest.java
+++ b/src/test/java/rx/internal/operators/OperatorTakeTest.java
@@ -19,7 +19,7 @@
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
-import java.util.Arrays;
+import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 
@@ -27,10 +27,13 @@
 import org.mockito.InOrder;
 
 import rx.*;
+import rx.Observable;
 import rx.Observable.OnSubscribe;
+import rx.Observer;
 import rx.exceptions.TestException;
 import rx.functions.*;
 import rx.observers.*;
+import rx.plugins.RxJavaHooks;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
 
@@ -457,4 +460,39 @@ public void takeZero() {
         ts.assertCompleted();
     }
 
+    @Test
+    public void crashReportedToHooks() {
+        final List<Throwable> errors = Collections.synchronizedList(new ArrayList<Throwable>());
+        RxJavaHooks.setOnError(new Action1<Throwable>() {
+            @Override
+            public void call(Throwable error) {
+                errors.add(error);
+            }
+        });
+
+        try {
+            Observable.just("1")
+                .take(1)
+                .toSingle()
+                .subscribe(
+                        new Action1<String>() {
+                            @Override
+                            public void call(String it) {
+                                throw new TestException("bla");
+                            }
+                        },
+                        new Action1<Throwable>() {
+                            @Override
+                            public void call(Throwable error) {
+                                errors.add(new AssertionError());
+                            }
+                        }
+                );
+            
+            assertEquals("" + errors, 1, errors.size());
+            assertTrue("" + errors.get(0), errors.get(0).getMessage().equals("bla"));
+        } finally {
+            RxJavaHooks.setOnError(null);
+        }
+    }
 }

From 7e3879abfb32eeebb38c970195a7f1e354eb1f82 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 31 Mar 2018 17:27:03 +0200
Subject: [PATCH 261/263] Release 1.3.8

---
 CHANGES.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 40d826708e..31299c26f8 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,15 @@
 # RxJava Releases #
 
+### Version 1.3.8 - March 31, 2018 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.8%7C))
+
+RxJava 1.x is now officially **end-of-life (EOL)**. No further developments, bugfixes, enhancements, javadoc changes, maintenance will be provided by this project after version **1.3.8**.
+
+Users are encourage to [migrate to 2.x](https://github.com/ReactiveX/RxJava/wiki/What's-different-in-2.0). In accordance, the wiki will be updated in the coming months to describe 2.x features and properties.
+
+#### Bugfixes
+
+- [Pull 5935](https://github.com/ReactiveX/RxJava/pull/5935): Fix `take()` to route late errors to `RxJavaHooks`.
+
 ### Version 1.3.7 - March 21, 2018 ([Maven](http://search.maven.org/#artifactdetails%7Cio.reactivex%7Crxjava%7C1.3.7%7C))
 
 #### Bugfixes

From 2ea5f309484d395efd3cac49a8e4b18e4302d061 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Sat, 31 Mar 2018 17:44:28 +0200
Subject: [PATCH 262/263] 1.x: readme update about EOL

---
 README.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/README.md b/README.md
index 3525242ea4..21176e556d 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,13 @@
 # RxJava: Reactive Extensions for the JVM
 
+## End-of-Life notice
+
+As of March 31, 2018, The RxJava 1.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 1.x line.
+
+Users are encouraged to migrate to [2.x](https://github.com/ReactiveX/RxJava) which is currently the only official RxJava version being managed.
+
+----------------------------------
+
 <a href='https://travis-ci.org/ReactiveX/RxJava/builds'><img src='https://travis-ci.org/ReactiveX/RxJava.svg?branch=1.x'></a>
 [![codecov.io](http://codecov.io/github/ReactiveX/RxJava/coverage.svg?branch=1.x)](http://codecov.io/github/ReactiveX/RxJava?branch=1.x)
 [![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.reactivex/rxjava/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.reactivex/rxjava)

From a62edb68aa37899320661225ea4944b1b73ab802 Mon Sep 17 00:00:00 2001
From: David Karnok <akarnokd@gmail.com>
Date: Tue, 2 Mar 2021 12:59:56 +0100
Subject: [PATCH 263/263] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 21176e556d..a0eabf5886 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 
 As of March 31, 2018, The RxJava 1.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 1.x line.
 
-Users are encouraged to migrate to [2.x](https://github.com/ReactiveX/RxJava) which is currently the only official RxJava version being managed.
+Users are encouraged to migrate to [3.x](https://github.com/ReactiveX/RxJava) which is currently the only official RxJava version being managed.
 
 ----------------------------------